branches/mty-makai/mty.c

/***********************************************************************
 *
 *      file: mty.c
 *
 *      Ü AŇÄŽB
 *
 *      $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>

#ifndef __ICL
 #include <unistd.h>
 #include <libgen.h>
#endif /* not __ICL */

#include <limits.h>
#ifdef REON
 #ifdef ONI
  #include <onigposix.h>
 #else /* ONI */
  /* #include <rxposix.h> */
  #include <regex.h>
 #endif /* ONI */
#endif /* REON */

#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"

#define TRIP_LEN 10

#define MAKAI_TRUE  1
#define MAKAI_FALSE 0

#define MIN_THREAD  1
#define MAX_THREAD 32
int     nThread = 0;
uint64_t        pmask = 0;

#define MIN_UME 3
#define MAX_UME 6
unsigned char   umeStr[10];
int     umeLen;

FILE    *nfp;   /* S */
FILE    *cfp;   /* ż */
FILE    *tfp;   /* ŞČOĚÁęő */
#ifdef REON
FILE    *rfp;   /* łK\ť */
#endif /* REON */

/*
 Cygwin 32bit
 time_t = long = int
 INT_MIN                              -2147483648
 INT_MAX                               2147483647
 (2009 - 1970)  * 365 * 24 * 60 * 60 = 1229904000
 2147483647 - 1229904000 =              917579647 
 10y * 365 * 24 * 60 * 60 =             315360000

 perl -e 'use POSIX;printf(strftime("%Y/%m/%d %T\n",localtime (1234567890)));'
*/
#define MIN_SOFF -1229904000
#define MAX_SOFF   315360000
unsigned int    seed;
int     seedOffset;
int     verbose;

#define   MAX_GEAR   10
#define   MIN_GEAR    1
#define   DEF_GEAR   10
int     gear;

#ifdef KEYLOG
#define   KEY_LOG_FILE   "keylog.txt"
int     keyLog = MAKAI_FALSE;
#endif /* KEYLOG */

#ifdef SELF
#define   SELF_LIM_CNT   50
#define   SELF_LIM_SEC   60 * 60 * 1000 /* 1h */
#endif /* SELF */

unsigned char   saltChar[2];

#ifdef ALLKEY
unsigned char   fixedSaltChar[2];
#endif /* ALLKEY */

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

/* ŽNX */
static
struct
{
  unsigned short map[256];
} kcls[8 + 8];

/* gŁŽNX */
#define KCLS_DT0 64
#define KCLS_DT1 128
#define KCLS_K2 256

int     special = 0;
#define ST_ALLN 1      /* S */
#define ST_NIKO 1<<0x1 /* ń\ */
#define ST_BUOO 1<<0x8 /* Ô¨ */
#define ST_DOSU 1<<0x9 /* { */
#define ST_CHIN 1<<0xb /* żń Uni ĹÍ´QpĚtO */
#define ST_EROI 1<<0xc /* G Uni ĹÍgňĚtO */
#define ST_HREN 1<<0xd /* ňA */
#define ST_YAKU 1<<0xe /* Ş_ */

#ifdef REON
#define REGEXPLEN 1024
char regExpStr[REGEXPLEN];
regex_t regExp;
#endif /* REON */

void
comment( str )
char    *str;
{
  if ( strlen( str ) >= 4 ) {
   if ( str[1] == '[' && str[3] == ']' ) {
    switch ( str[2] ) {
     case '0': special |= ST_ALLN; break;
     case '1': special |= ST_NIKO; break;
     case '8': special |= ST_BUOO; break;
     case '9': special |= (ST_DOSU | ST_ALLN); break;
     case 'd': special |= ST_HREN; break;
     case 'e': special |= ST_YAKU; break;
     case 'Y': special |= ST_CHIN; break;
     case 'Z': special |= ST_EROI; break;
#ifdef KEYLOG
     case 'K': keyLog = MAKAI_TRUE; break;
#endif /* KEYLOG */
     case 'S':
      seedOffset = atoi( str + 4 );
      if ( seedOffset < MIN_SOFF || seedOffset > MAX_SOFF ) {
       fprintf( stderr, "ĚíĚItZbgÍA%d Čă %d ČşĹwčľÄËB\n", MIN_SOFF, MAX_SOFF );
       fprintf( stderr, "%d ÍÍÍOČĚĹłľÜˇB\n", seedOffset );
       seedOffset = 0;
      }
      break;
     case 'R':
#ifdef REON
      if ( strlen( str ) >= REGEXPLEN ) {
       fprintf( stderr, "łK\ť (%s) ŞˇˇŹ", str );
       exit( 1 );
      }
      strcpy( regExpStr, str + 4 );
      if ( regcomp( &regExp, regExpStr, REG_NOSUB|REG_EXTENDED ) != 0 ) {
       fprintf( stderr, "łK\ť (%s) Ş¨Šľ˘H\n", str );
       exit( 1 );
      }
#else /* REON */
      fprintf( stderr, "ąĚoCiÍAłK\ťđT|[gľÄ˘ÜšńB\n" );
      fprintf( stderr, "%s ÍłľÜˇB\n", str );
#endif /* REON */
      break;
    }
   }
  }
}

#ifndef ALLKEY
/* wčłę˝NXĆüÁÄ˘éL[ŠçAclassify đs¤ */
void
key_make_map(uint8_t *key, int n)
{
  int i, j;
  unsigned c = kcls[n].map[key[n]];

  /* ĹăĚŞÍ class map đśŹˇéKviV */
/* MAKAI memo
 6byte ß˝ĚŽ 
 şĚűĚ if (n == 6) Ćľ
*/
  if ( n >= 6 ) return;

  for ( i = 0; i < 256; i++ ) {
   unsigned bm = 0;
   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 ( 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);
    }
   }
   kcls[n + 1].map[i] = bm;
   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 0
  if ( n == 6 ) kcls[7].map[0x00] |= KCLS_AN;
#endif /* 0 */
}
#endif /* not ALLKEY */

/* }bvŠçśđEÁÄZbg */
unsigned
key_set(int n, unsigned ch)
{
  int cnt = 0, i;

#ifdef NOMORE
  ch %= 256;
#endif /* NOMORE */

  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 đZbg */
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))
                {
                  /* Zbg */
                  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];
                        }
                }
        }
}

/* wčłę˝NXĚJnlÉZbg
   źOĚśĚNXÉçęé */
int
key_reset(uint8_t *key, int n)
{
  static char   firstCall = 1;

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

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

  if ( n >= umeLen ) {
#ifdef ALLKEY
   for ( ; n < 7; n++ ) {
    key[n] = 1;
   }
   key[7] = 0;
   return 1;
#else /* ALLKEY */
   key[n] = key_set(n, 0);
#endif /* ALLKEY */
  } else {
   if ( umeStr[0] == '\0' ) {
#ifdef ALLKEY
    key[n] = rand() % 0x7f + 1;
#else /* ALLKEY */
    key[n] = key_set(n, rand());
#endif /* ALLKEY */
   } else {
    key[n] = umeStr[n];
   }
#ifdef KEYLOG
   /* őóÔĚL^ */
   if ( keyLog && (n == umeLen - 1) ) {
    FILE        *fp;
    int i;
        struct timeb    tb;
        struct tm       *plt;

        ftime( &tb );
        plt = localtime( &tb.time );

#ifdef OLDDEBUG
    printf( "\nť§[éĆżĽ[ńśI\n" );
#endif /* DEBUG */
    if ( (fp = fopen( KEY_LOG_FILE, "at" )) == NULL ) {
     perror( KEY_LOG_FILE );
     exit( 1 );
    }
    for ( i = 0; i < umeLen; i++ ) {
     fprintf( fp, "%02x", key[i] );
    }
    fprintf( fp, "\t%04d/%02d/%02d %02d:%02d:%02d.%03d\n",
             plt->tm_year + 1900, plt->tm_mon + 1, plt->tm_mday,
             plt->tm_hour, plt->tm_min, plt->tm_sec, tb.millitm );
    fclose( fp );
   }
#endif /* KEYLOG */
  }

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

#ifndef ALLKEY
  /* Zbgłę˝śđłÉALĚśNXđßé */
  key_make_map(key, n);
#endif /* not ALLKEY */

  return key_reset(key, n + 1);
}

/* wčłę˝ŽóÔĚĹAL[đĐĆÂißé
   ŔSÉCNgĹŤ˝ę true đÔˇ */
static
int
key_inc(uint8_t *key, int n)
{
#if 0
if ( n != 7 ) {
printf( "%d : %02x %02x %02x %02x %02x %02x %02x %02x\n",
        n, key[0], key[1], key[2], key[3], key[4], key[5], key[6], key[7] );
}
#endif /* 0 */

  if ( n >= 8 ) {
   return 0;
  } else if ( n == 7 ) {
/* MAKAI memo
2^N_STRIDE Ş˘ÁŘńÉvZˇéÂ
 MMX 6  : 64 Â
 SSE2 7 : 128 Â
ąĚ˝ßĹăĚoCgĚißűŞĎíé
*/
   uint8_t      o_k = (key[7] + (1 << N_STRIDE)) & 0x7F;
   if ( !o_k ) {
    return 0;   /* CNgĹŤČŠÁ˝ĆŤÍÖiß¸ŇÂ */
   } else {
    key[7] = o_k;
    return 1;
   }
  } else if ( key_inc( key, n+1 ) ) {
   return 1;
  }

  /* Salt ÍCNgľČ˘ńŠÉˇé */
  if ( n == 1 || n == 2 ) {
   return 1;
  }

#ifdef ALLKEY
  key[n] = ( key[n] & 0x7F ) + 1;
  if ( key[n] >= 0x80 ) {
   key[n] = 0xFF;       /* ÉËüłšČ˘˝ß */
   return 0;
  }
  key_reset( key, n + 1 );
  return 1;
#endif /* ALLKEY */

  /* ŔŰÉâľÄÝé */
  assert( n >= 3 );
  for ( ;; ) {
          if (n <= 3
                  && !(key[n] & 0x80)
                  && kcls[n].map[key[n] ^ 0x80] & (KCLS_DT0))
                {
                  /* źpJ^JiĚ1oCgÚ */
                  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]])
                {
#ifndef ALLKEY
                  key_make_map(key, n);
#endif /* not ALLKEY */
                  key_reset(key, n + 1);
                  return 1;
                }
        }
}

/* ŽđŽSÉZbgˇé
   SaltŕZbgľźˇ */
static
void
key_init(uint8_t *key)
{
  int i, j;

  key[8] = 0;

#ifndef ALLKEY
  /* ú}bvđgŢ */
  for ( i = 0; i < 256; i++ ) {
   unsigned bm = 0;

   for ( j = 0; j < 256; j++ ) {
    bm |= cp932[256 * i + j];
   }
   kcls[0].map[i] = bm & (KCLS_AN | KCLS_KA | KCLS_K1);
   if ( i >= 128 ) {
    kcls[0].map[i - 128] |= kcls[0].map[i];
   }
  }
#endif /* not ALLKEY */

  key_reset(key, 0);
}

/***************************************************************
 *
 *      ĹčL[ĚśŹ
 *
 *      ęŠ Big Endian ÉńÎĚć¤ÉŠŚéžë¤Ş
 *      ĹÉUçÎÁÄ˘é kludge Éćč
 *      ALU_T Ş 64 rbgĹ éŔčAąęĹâčČŽB
 *
 */

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 ĚZbg
 *      IyhĚItZbgđŤˇŚÄńÁÄéĚĹÓ
 *
 */

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

  static unsigned char  *s2c = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

  for ( i = 0; i < 2; i++ ) {
   unsigned     s;
#ifdef ALLKEY
   if ( fixedSaltChar[0] != '\0' ) {
    saltChar[i] = fixedSaltChar[i];
    for ( s = 0; s2c[s] != '\0' && s2c[s] != saltChar[i]; s++ )
     ;
        assert( s2c[s] != '\0' );
   } else {
    s = rand() % 64;
    saltChar[i] = s2c[s];
   }
#else /* ALLKEY */
   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;
#ifdef OTAKU
{
   unsigned s2;
   do {
    s2 = rand() % 64;
   } while ( s == s2 );
   s = s2;
}
#endif /* OTAKU */
   saltChar[i] = s2c[s];
#endif /* ALLKEY */

   for ( j = 0; j < 6; j++ ) {
    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);
   }
  }
}

#define USEC_SEC 1000   /* 1b */

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);

  if ( ofp != nfp ) {
   vfprintf(stdout, fmt, ap);
  }

  r = vfprintf(ofp, fmt, ap);
  va_end(ap);
#ifdef HITEXIT
  exit( 0 );
#endif /* HITEXIT */
  if (r > 0)
        return r;
  perror("log_printf");
  exit(errno);
}

static
void
hit( fp, hash, key, kk, k, kind, dotrans )
FILE    *fp;
char    *hash;
uint8_t *key;
int     kk;
int     k;
unsigned char   *kind;
int     dotrans;
{
  struct timeb  tb;
  struct tm     *plt;
  int   namaKey;
  uint8_t       buf[32];

  ftime( &tb );
  plt = localtime( &tb.time );

  memcpy( buf, key, 8 );
  buf[8] = buf[9] = 0;
  buf[7] = (buf[7] & -(1 << N_STRIDE) & 0x7F) + ALU_BITS * kk + k;

  namaKey = MAKAI_TRUE;
#ifndef NAMA
  if ( dotrans ) {
   if ( translate( buf, 0, 1 ) ) {
    namaKey = MAKAI_FALSE;
   }
  }
#endif /* NAMA */

  if ( namaKey ) {
   log_printf( fp, "%s ##%02x%02x%02x%02x%02x%02x%02x%02x%c%c"
               "\t%04d/%02d/%02d %02d:%02d:%02d.%03d"
               " %s ś\n",
               hash,
               buf[0], buf[1], buf[2], buf[3],
               buf[4], buf[5], buf[6], buf[7],
               saltChar[0], saltChar[1],
               plt->tm_year + 1900, plt->tm_mon + 1, plt->tm_mday,
               plt->tm_hour, plt->tm_min, plt->tm_sec, tb.millitm,
               kind );
  } else {
   log_printf( fp, "%s #%s"
               "\t%04d/%02d/%02d %02d:%02d:%02d.%03d"
               "\t(%02X %02X %02X %02X %02X %02X %02X %02X/%02X)"
               " %s\n",
               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], buf[8],
               kind );
  }
}

/***************************************************************
 *
 *      CPU capabilities đćž
 *      [XXX]  ÜčÉŕĂ˘vZbTĚąĆÍlŚČ˘B
 *
 *      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);
}

/***************************************************************
 *
 *      ob`ppPbg
 *
 */

static
struct PACKET_CRYPT64 *
packet_create(int n,    /* pPbg */
                          int tn,       /* övfÉÄKvČ[N */
                          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);
  /* o_ íš */
  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

  /* ŕĚúť
         Rs[ľÄńéĚÍAľ§ÉÍ
         ĹIvfĚPcđjÁÄľÜ¤ąĆÉČéĚĹ
         Ç¤šŹxŕvłęČ˘ľx^R[h */
  for (i = 0; i < n; i++)
        {
          int j, k;

          /* t[16] ÍAŕZĹgpˇéAall 1 ŞüÁÄ˘é */
          memset(&pkts[i].param64.t[T_INV], -1, sizeof(SLICE));

          /* ĹčL[ĚśŹ */
          key_init_sk(&pkts[i].key64);

          /* L[XPW[đąąÉľßÄ¨
                 ]Í 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];

          /* OĚ˝ßAŽđąąĹżŻÄ¨(sv?) */
          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)
#if 0
#undef thread_set_priority
#endif
#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)  || defined(__FreeBSD__)

#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);

  /* ťÝŠç^CAEgđßé
         ßńÇš[ */
  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__)

/* ftHgXPW[O|V[ĹÍ
   DćxÝčľ˝čAChXbhNąľÄŕ
   ¨ŕľëČ˘ĚĹAťĚÖńÍĄăĚ¤ŰčB */

#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 ĹÍAXbhPĘĚXPW[OÉîüĹŤČ˘B */

#endif

#else
#error "configuration not supported"
#endif

struct THREAD_PARAM
{
  /* ČşÍ¤ĘîńĚRs[ */
  CODE_T *code;
  THREAD_EV_T *p_ev_ks_activated;
  ATOMWORD_T volatile *p_nidle;         /* ŇżÉüÁ˝çÁ */

  /* ČşÍXbhĹL */
#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
/* todo WIN32 ĹČ˘ĆŤĚ n {\Ś */
  if (popcnt64(mask_s) == 1)
        /* ˝ŕž¤Ü˘ */;
  else if (mask == mask_s)
        fprintf(stderr,
                        "ĘíĚ%d{ĆÍćžÁ˝ŕĚĹˇB\n",
                        popcnt64(mask));
  else
        fprintf(stderr,
                        "ĹŹÍĚ%g{ĚÍĹÄŤĆ¤ÉŞńÎéćB\n",
                        (double)popcnt64(mask) / popcnt64(mask_s));
  return mask;

#elif defined(__linux__)        /* sched.h gŁ */

  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;

#elif defined( __FreeBSD__ )

#include <sys/sysctl.h>

  int   i;
  uint64_t m;
  int nCPU;
  int mib[2];
  size_t len;

  mib[0] = CTL_HW;
  mib[1] = HW_NCPU;
  len = sizeof( nCPU );
  sysctl( mib, 2, &nCPU, &len, NULL, 0 );
  m = (1ULL << nCPU) - 1;

  return m;

#elif defined( __sun__ )

#include <sys/unistd.h>
#include <sys/processor.h>

  uint64_t m;
  processorid_t i, cpuid_max;

  m = 0;
  cpuid_max = sysconf( _SC_CPUID_MAX );
  for ( i = 0; i <= cpuid_max; i++ ) {
   if ( p_online( i, P_STATUS ) == P_ONLINE ) {
    m |= 1ULL << i;
   }
  }

  return m;

#else

  /* XXX vZbTđ˛×ă°Äžł˘ */
  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;

          /* L[Šçvđćčoˇ */
          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;

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

                          /* vŇż */
                          r = thread_wait_event(*param->p_ev_ks_activated, tmo);

                          if (tmo == THREAD_INFINITE)
                                {
                                  /* Nąłę˝ */
                                  LOCK_DEC(param->p_nidle);
                                }
                          else if (r >= 0)
                                {
                                  /* ŕ¤żĺÁĆQÄÝé */
                                  thread_sleep(tmo);
                                }

                          /* ŠçĚDćxđßˇ
                                 (OŠçu[XgłęÄéŠŕ) */
#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);

          /* ŔsľÄÝé */
          CALL_CRYPT64(code, &pkt->key64, &pkt->param64);

          /* ĘđL[É˝˝ŤŢ */
          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);
        }
}

char
*bname( char *path )
{
  char  *p;

#ifdef OLDEBUG
  printf( "path <%s>\n", path );
#endif /* DEBUG */

  for ( p = path; *p != '\0'; p++ )
   ;
  while ( *p != '/' && *p != '\\' && p != path ) {
   if ( *p == '.' ) {
    *p = '\0';
   }
   p--;
  }
  if ( p != path ) {
   p++;
  }

#ifdef OLDEBUG
  printf( "p <%s>\n", p );
#endif /* DEBUG */

  return( p );
}

void
usage( path )
char    *path;
{
  char  *myName;

  myName = bname( path );
#ifdef ALLKEY
  printf( "%s [-t num] [-m mask] [-s num] [-g num] [-k salt] [-v] [\"str\"]\n", myName );
#else /* ALLKEY */
  printf( "%s [-t num] [-m mask] [-s num] [-g num] [-v] [\"str\"]\n", myName );
#endif /* ALLKEY */
  printf( " -t num : őXbh ( %d  num  %d )\n",
           MIN_THREAD, MAX_THREAD );
  printf( " -m mask : Ŕsˇé CPU đwčˇé}XN ( 1 rbg  mask Ěrbg  %d rbg )\n",
          MAX_THREAD );
  printf( " -s num : Ěí ( 1  num  %u )\n", UINT_MAX );
  printf( " -g num : ŞńÎčŽ ˘ ( %d (âéCČľ)  num  %d (tp[), ftHgÍA%d )\n", MIN_GEAR, MAX_GEAR, DEF_GEAR );
#ifdef ALLKEY
  printf( " -k salt : đwč\n" );
#endif /* ALLKEY */
  printf( " -v : çˇbZ[W\n" );
  printf( " str : ćŞÉßŢśń ( %d  str ĚoCg  %d )\n",
           MIN_UME, MAX_UME );
}

/* qbgÉÍoÍt@CÖĚ|C^đÔˇ */
FILE *
checkSpecial( trip, kind )
char    *trip;
unsigned char   *kind;
{
  if ( special & ST_CHIN ) {
   /* ^Chi(r */
   if ( trip[0] == 'C' && trip[1] == 'h' && trip[2] == 'i' &&
        trip[3] == 'n' && trip[4] == 'k' && trip[5] == 'o' ) {
    strcpy( kind, "ż" );
    return( cfp );
   }
  }

  if ( special & ST_BUOO ) {
   /* Ô¨ [A-Za-z]aoo[A-Za-z]uoo$ */
   if ( trip[3] == 'a' && trip[4] == 'o' && trip[5] == 'o' &&
        trip[7] == 'u' && trip[8] == 'o' && trip[9] == 'o' &&
        isalpha( trip[2] ) && isalpha( trip[6] ) ) {
    strcpy( kind, "Ô" );
    return( tfp );
   }
  }

  if ( special & ST_EROI ) {
   int  i;
   /* G˘l^ń\ ťĚ 1 looooloooo */
   if ( trip[0] == trip[5] &&
        trip[1] == trip[2] && trip[1] == trip[3] && trip[1] == trip[4] &&
        trip[1] == trip[6] && trip[1] == trip[7] && trip[1] == trip[8] &&
        trip[1] == trip[9] ) {
    strcpy( kind, "G" );
    return( tfp );
   }
   /* G˘l^ń\ ťĚ 2 [./] */
   for ( i = 0; i < TRIP_LEN; i++ ) {
    if ( trip[i] != '.' && trip[i] != '/' ) {
     goto NOEROI;
    }
   }
   strcpy( kind, "G" );
   return( tfp );
  }
  NOEROI:

  if ( special & ST_NIKO ) {
   /* ń\ */
   int  i;
   char ch1, ch2;
   ch1 = trip[0];
   for ( i = 1; i < TRIP_LEN; i++ ) {
    if ( trip[i] != ch1 ) break;
   }
   ch2 = trip[i];
   for ( ; i < TRIP_LEN; i++ ) {
    if ( trip[i] != ch1 && trip[i] != ch2 ) goto NONIKO;
   }
   strcpy( kind, "ń" );
   return( tfp );
  }
  NONIKO:

  if ( special & ST_YAKU ) {
   /* Ş_ */
   if ( trip[0] == trip[1] && trip[0] == trip[2] &&
        trip[3] == trip[4] && trip[3] == trip[5] &&
        trip[6] == trip[7] && trip[6] == trip[8] && trip[9] == '.' ) {
    strcpy( kind, "Ş" );
    return( tfp );
   }
  }

  /* ňAÖAĚR[hÍAžŰŘÝ Celeron/rc ě */
  if ( special & ST_HREN ) {
   /* ňA */
   int  w, x = 0, y = 0;
   for ( w = 0; w < TRIP_LEN; w++ ) {
    if ( trip[w] == trip[0] ) x += 1;
    if ( trip[w] == trip[1] ) y += 1;
    if ( x >= 8 || y >= 8 ) {
     strcpy( kind, "ň" );
     return( tfp );
    }
   }
  }

  if ( special & ST_ALLN ) {
   /* S Š { */
   if ( isdigit( trip[0] ) && isdigit( trip[1] ) && isdigit( trip[2] ) &&
        isdigit( trip[3] ) && isdigit( trip[4] ) && isdigit( trip[5] ) &&
        isdigit( trip[6] ) && isdigit( trip[7] ) && isdigit( trip[8] ) &&
        isdigit( trip[9] ) ) {
    if ( special & ST_DOSU ) {
     /* S & ńś */
     if ( trip[0] == trip[9] && trip[1] == trip[8] && trip[2] == trip[7] &&
          trip[3] == trip[6] && trip[4] == trip[5] ) {
      strcpy( kind, "{" );
      return( tfp );
     }
     /* S & oA */
     if ( trip[0] == trip[1] && trip[2] == trip[3] && trip[4] == trip[5] &&
          trip[6] == trip[7] && trip[8] == trip[9] ) {
      strcpy( kind, "{" );
      return( tfp );
     }
     /* S & RF */
     if ( trip[0] == trip[5] && trip[1] == trip[6] && trip[2] == trip[7] &&
          trip[3] == trip[8] && trip[4] == trip[9] ) {
      strcpy( kind, "{" );
      return( tfp );
     }
     /* ĹĺĆĹŹÍA 8 AĹoéĚĹí */
    } else {
     strcpy( kind, "" );
     return( nfp );
    }
   }
  }

  return( NULL );
}

/***************************************************************
 *
 *      C[vĆŠ
 *
 */

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;

#if defined(WIN32)
#define YOUSUMI 6
  int   maxSpeed; /* ębÔÉőľ˝ÂĚĹĺl (YOUSUMI ńvŞ) */
  int   sCnt; /* Źxđ\Śľ˝ń */
  int   lCntMax; /* Sleep() Ě˝ßĚ[vĹĺl */
  int   lCnt; /* Sleep() Ě˝ßĚ[vJE^ */
#endif /* WIN32 */

#define UPDATE_INTERVAL 8       /* Źx\ŚĚÔu b */
  struct status {
    uint64_t startTime; /* Jn ~b */
    uint64_t lastTime;  /* ĹăÉ\Śľ˝ ~b */
    uint64_t loop;              /* őÂ */
    uint64_t lastloop;  /* ĹăÉ\Śľ˝Ě loop */
  } status;
  uint64_t curTime;
  uint32_t upd_int = 0;

#if defined(WIN32)
  SetPriorityClass( GetCurrentProcess(), IDLE_PRIORITY_CLASS );
  maxSpeed = 0;
  sCnt = 0;
  lCntMax = 0;
  lCnt = 0;
#endif

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

  nThread = 0;
  pmask = 0;
  seed = 0;
  seedOffset = 0; /* R}hCIvVĹÍČ˘ŞAąąĹúť */
  verbose = 0;
  gear = DEF_GEAR;
#ifdef ALLKEY
  fixedSaltChar[0] = '\0';
  while ( (optChar = getopt(argc, argv, "t:m:s:g:k:vh")) != EOF ) {
#else /* ALLKEY */
  while ( (optChar = getopt(argc, argv, "t:m:s:g:vh")) != EOF ) {
#endif /* ALLKEY */
   switch ( optChar ) {
    case 't':
     nThread = atoi( optarg );
     if ( nThread < MIN_THREAD || nThread > MAX_THREAD ) {
      usage( argv[0] );
      exit( 1 );
     }
     break;
    case 'm':
     if ( strlen( optarg ) > MAX_THREAD ) {
      usage( argv[0] );
      exit( 1 );
     }
     for ( chPtr = optarg; *chPtr != '\0'; chPtr++ ) {
      pmask <<= 1;
      switch ( *chPtr ) {
       case '0':
        /* ČÉŕľČ˘ */
        break;
       case '1':
        pmask |= 1;
        break;
       default:
        usage( argv[0] );
        exit( 1 );
        break;
      }
     }
     if ( pmask < MIN_THREAD ) {
      usage( argv[0] );
      exit( 1 );
     }
     break;
    case 's':
     if ( optarg[0] == '-' ) {
      usage( argv[0] );
      exit( 1 );
     }
     seed = (unsigned int)atoi( optarg );
     if ( seed < 1 || seed > UINT_MAX ) {
      usage( argv[0] );
      exit( 1 );
     }
     break;
    case 'g':
     gear = atoi( optarg );
     if ( gear < MIN_GEAR || gear > MAX_GEAR ) {
      usage( argv[0] );
      exit( 1 );
     }
     break;
#ifdef ALLKEY
    case 'k':
     if ( strlen( optarg ) != 2 ) {
      usage( argv[0] );
      exit( 1 );
     }
     for ( i = 0; i < 2; i++ ) {
      if ( !isdigit( optarg[i] ) && !isalpha( optarg[i] ) &&
           optarg[i] != '.' && optarg[i] != '/' ) {
       usage( argv[0] );
       exit( 1 );
      }
      fixedSaltChar[i] = optarg[i];
     }
     break;
#endif /* ALLKEY */
    case 'v':
     verbose = 1;
     break;
    case 'h':
     usage( argv[0] );
     exit( 0 );
     break;
    default:
     usage( argv[0] );
     exit( 1 );
   }
  }

  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 );
  }
}
#ifdef REON
  regExpStr[0] = '\0';
#endif /* REON */

#ifdef NAMA
  fprintf(stderr, "śL[o[W\n");
  fprintf(stderr, "ŞęAgbvŞťŻ˝ęA\n");
  fprintf(stderr, "http://trip.is-a-geek.net/test/read.cgi/ra8bbs/1217089930/\n");
  fprintf(stderr, "ÉńˇéĆĚo[WĹüPłęéŠŕB\n\n");
#endif /* NAMA */

#ifdef MAKEY
  fprintf(stderr, "L[óÔo[WÉÂŤAVEgÉÍ¨ˇˇßĹŤČ˘B\n\n");
#endif /* MAKEY */

#ifdef ALLKEY
  fprintf(stderr, "^ESóÔo[WÉÂŤAVEgÉÍ¨ˇˇßĹŤČ˘B\n\n");
#endif /* MAKEY */

  if ( !cpuid_issupported() ) {
   fprintf( stderr, "ąĚÂŤĹçšéąĆŞzčłęÄ˘ÜšńB\n" );
   exit( 1 );
  }

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

  /* ^QÇÝÝ */
  root_expr = expr_parse( "target.txt" );

  if ( verbose ) {
   printf( "ÁęőIvV : " );
   if ( special & ST_DOSU ) {
    printf( "{ " );
   } else {
    if ( special & ST_ALLN ) {
     printf( "S " );
    }
   }
   if ( special & ST_EROI ) {
    printf( "G " );
   }
   if ( special & ST_NIKO ) {
    printf( "ń\ " );
   }
   if ( special & ST_BUOO ) {
    printf( "Ô¨ " );
   }
   if ( special & ST_CHIN ) {
    printf( "żń " );
   }
   if ( special & ST_HREN ) {
    printf( "ňA " );
   }
   if ( special & ST_YAKU ) {
    printf( "Ş_ " );
   }
   if ( special ) {
    printf( "II\n" );
   } else {
    printf( "I[ItI\n" );
   }
   if ( seedOffset != 0 ) {
    printf( "ĚíĚItZbg = %d\n", seedOffset );
   }
#ifdef REON
   if ( regExpStr[0] != '\0' ) {
    printf( "łK\ť : %s\n", regExpStr );
   }
#endif /* REON */
   if ( gear != DEF_GEAR ) {
    printf( "ŞńÎčŽ ˘ : %d\n", gear );
   }
#ifdef KEYLOG
   if ( keyLog == MAKAI_TRUE ) {
    printf( "őľ˝L[óÔĚMO\n" );
   }
#endif /* KEYLOG */
  }

  /* R[hđśŹEWJ
         NŽ\čXbhÉśÄ
         śŹˇéR[hđĎŚé */
  sfp = scoreboard_open();
  /* prologue & RA[v */
  fwrite( crypt64_descs[0]->pro, 1,
          crypt64_descs[0]->cmp_pro - crypt64_descs[0]->pro, sfp );

   /* proc_mask Égpˇé CPU Ě}XNđZbg */
  if ( pmask == 0 ) {
   /* wčŞČŻęÎAgŚé CPU S */
   proc_mask = thread_avail();
  } else {
   /* wčłę˝ CPU ĚśÝ`FbNBžŞAĄÍ Win32 ĚR[hľŠČ˘B */
#ifdef WIN32
   DWORD_PTR    processMask, systemMask;
   if ( GetProcessAffinityMask( GetCurrentProcess(), &processMask, &systemMask )
        == 0 ) {
    printf( "CPU ĚčÄÉ¸s ťĚ 1\n" );
    exit( 1 );
   }
   if ( (processMask & pmask) != pmask ) {
    printf( "ťńČ CPU ÍËĽI\n" );
    exit( 1 );
   }
#endif /* WIN32 */

   proc_mask = pmask;
   printf( "CPU : " );
   for ( i = 0; i < MAX_THREAD; i++ ) {
    if ( pmask & 1 ) {
     printf( "%d ", i );
    }
    pmask >>= 1;
   }
   printf( "đgpľÜˇB\n" );

    /* CPU ĚčÄBžŞAĄÍ Wi(r */
#ifdef WIN32
   if ( SetProcessAffinityMask( GetCurrentProcess(), proc_mask ) == 0 ) {
    printf( "CPU ĚčÄÉ¸s ťĚ 2\n" );
    exit( 1 );
   }
#endif /* WIN32 */
  }

  /* XbhĚwčŞČ˘ęÍAproc_mask ŠçQbc */
  if ( nThread == 0 ) {
   nThread = popcnt64( proc_mask );
  }

  fprintf( stderr, "%d ÂĚőXbhđśŹ\n", nThread );

  if ( nThread == 1 ) {
   npkts = 1;
   pkts_vacant = 1;
   code_cmp = 0;
  } else {
   /* epilogue */
   fwrite( crypt64_descs[0]->ep, 1,
           crypt64_descs[0]->ep_end - crypt64_descs[0]->ep, sfp );
   /* äríĚÝđśŹ(Oź) */
   code_cmp = ftell( sfp );
   fseek( sfp, (-code_cmp) & 63, SEEK_CUR );
   code_cmp = ftell( sfp );
   /* prologue */
   fwrite( crypt64_descs[0]->pro, 1,
           crypt64_descs[0]->crypt - crypt64_descs[0]->pro, sfp );
   npkts = 64;
   pkts_vacant = (uint64_t)-1;  /* (1 << 64) - 1 đvZľ˝Č˘ */
  }

  /* ärđśŹ */
  /* äríő */
  fwrite( crypt64_descs[0]->cmp_pro, 1,
          crypt64_descs[0]->cmp_ep - crypt64_descs[0]->cmp_pro, sfp );
  tn = synth_synthesize( sfp, root_expr );
  /* epilogue */
  fwrite( crypt64_descs[0]->cmp_ep, 1,
          crypt64_descs[0]->ep_end - crypt64_descs[0]->cmp_ep, sfp );
  /* R[hđÉ\čtŻé */
  code = scoreboard_map( sfp );

  /* L[Ěúť */
  if ( seed == 0 ) {
   seed = (unsigned int)time( NULL ) + seedOffset;
  }
  if ( verbose ) {
   printf( "Ěí = %u\n", seed );
  }
  srand( seed );

#ifdef KEYCHK
{
  int   i;

  for ( i = 0; i < 100000; i++ ) {
   printf( "%02x %02x %02x %02x %02x %02x %02x %02x\n",
           key[0], key[1], key[2], key[3], key[4], key[5], key[6], key[7] );
   key_init( key );
  }
  exit( 0 );
}
#endif /* KEYCHK */

  key_init( key );
  set_salt( code, crypt64_descs[0], key );

  /* ZpPbgđěŹ */
  pkts = packet_create( npkts, tn, key );
  pkt_hit = &pkts[npkts - 1];

  /* ¨śłńđĘY */
  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 * nThread, sizeof(*threads) );
   for ( i = 0; i < nThread; i++ ) {
    if ( ots < 0 ) {
     /* ŠŞŠgĚXPW[O
        ą[ä[nĚAvÍáßÉÝčˇéĚŞg(Šŕ) */
#ifdef WIN32
     h = GetCurrentProcess();
/* todo î{DćxĚÝčŞńÓÉ é */
     SetPriorityClass( h, BELOW_NORMAL_PRIORITY_CLASS );
#endif
#if defined( thread_set_priority )
     /* SĚÔ¨ßľÜˇ */
     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;
     /* ŠŞŠgĚcčĚÝčđA ĆĹâé */
     ots = i;
    } else {
     /* źXbhÍAââáßĚDćxĹB */
     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
     nthreads++;
    }
   }
  }

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

  if ( (tfp = fopen( "logspe.txt", "at" )) == NULL ) {
   perror( "logspe.txt" );
   return errno;
  }
  setvbuf( tfp, NULL, _IONBF, BUFSIZ );
  if ( (nfp = fopen( "lognum.txt", "at" )) == NULL ) {
   perror( "lognum.txt" );
   return errno;
  }
  setvbuf( nfp, NULL, _IONBF, BUFSIZ );
  if ( (cfp = fopen( "logchi.txt", "at" )) == NULL ) {
   perror( "logchi.txt" );
   return errno;
  }
  setvbuf( cfp, NULL, _IONBF, BUFSIZ );
#ifdef REON
  if ( (rfp = fopen( "logreg.txt", "at" )) == NULL ) {
   perror( "logreg.txt" );
   return errno;
  }
  setvbuf( rfp, NULL, _IONBF, BUFSIZ );
#endif /* REON */

  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();

#ifdef MINAST
#undef assert
#define assert(x)
#endif /* MINAST */

#ifdef SCTEST
{
  int   i;

  for ( i = 1; i < SCTEST; i++ ) {
   key_reset( key, 0 );
  }
  exit( 0 );
}
#endif /* SCTEST */

  /* Tő[vžźÁĆ */
  for ( ;; ) {
   struct PACKET_CRYPT64 *pkt_c;
   uint64_t cnt;
#if DEBUG>=1
   int cnt1, cnt2;
#endif
   int k, kk;

   /* äríóâ(may be NULL)
      ćÉL[Šçćčoˇ */
   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 );
    /* pPbgđ vacant ÉńľÄ¨ */
    pkts_vacant |= 1ULL << (pkt_c - pkts);
   }

   /* Salt`FWŇż */
   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 óÔĹÍAŠçŕvL[đâÁÂŻÉ˘ */
      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 );
      /* pPbgđ 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 `FWŞÂ\ */
     set_salt( code, crypt64_descs[0], key );
     if ( nthreads ) thread_signal_event( event_ks_activated );
     ks_activated = 1;
    }
   }

   /* ŽđL[É˝˝ŤÝÜé */
   if ( !ks_activated ) {
    /* Žđo^ľČ˘ */
    ;
   } else {
    for ( i = npkts - 1; i >= 0; i-- ) {
     if ( pkts_vacant & (1ULL << i) ) {
      int j;
      if ( i == npkts - 1 ) {
       /* OiĹA¨śłńŠçĘđŕçÁÄ˘˝çA˝ŕľČ˘ */
       if ( pkt_c != NULL ) continue;
      } else {
       /* OiĹćčoľ˝ÎŠčĚ¨śłńÍA¸dˇé */
       if ( &pkts[i] == pkt_c ) continue;
       /* queue full ĚęÍŠé */
       /* XXX 16 ÍÄŤĆ¤ */
       if ( WRAP( wp_crypt, NQ_CRYPT ) == WRAP( rp_crypt - 16, NQ_CRYPT )
            || q_crypt[WRAP( wp_crypt, NQ_CRYPT )] != NULL ) break;
      }
      /* ŽĚZbg */
      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 ) {
       /* iĹ CRYPT64->CMP */
       assert(pkt_c == NULL);
       pkt_c = &pkts[i];
       assert( pkt_c == pkt_hit );
      } else {
       /* L[É˝˝ŤŢ */
       while ( LOCK_CASP( &q_crypt[WRAP( wp_crypt, NQ_CRYPT )], &pkts[i], NULL )
               != NULL ) {
        /* ÝvăÍąąÉČ˘ */
        fprintf( stderr,
                 "q_crypt đľÄéĚÍNž? (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 );
       }
       LOCK_INC( &wp_crypt );
       pkts_vacant ^= 1ULL << i;
       assert( !(pkts_vacant & (1ULL << i)) );  /* íę */
      }
      /* ŽÁÍąńČĆąëÉÚŽ! */
      assert( ks_activated );
      if ( !key_inc( key, 6 ) && !key_inc( key, umeLen ) ) {
       /* ŽĚVbt q_crypt ŞJŻéÜĹAset_salt() ÍĹŤČ˘ */
#if DEBUG>=1
       fprintf( stderr, "********************************SHUFFLE!\n" );
#endif
       if ( nthreads ) thread_clear_event( event_ks_activated );
       key_reset( key, 0 );
       /* L[ĚŽŞJŻéÜĹAChóÔÉ */
       ks_activated = 0;
       /* Xbhđu[XgľÄńé */
#ifdef thread_set_priority
       for ( j = 0; j < nthreads; j++ ) {
        assert( threads != NULL );
        thread_set_priority( threads[j].th, THREAD_PRIORITY_NORMAL );
       }
#endif
       /* [vąsÍŕÍâsv */
       break;
      }
     }
    }
   }
   /* ˇéąĆŞČČÁÄ˘éę */
   if ( pkt_c == NULL ) {
    assert( !ks_activated );
    continue;
   }
   /* ÄÔ!
      LR úťÍATuW[ŕĹs¤×ľ
      FASTCALL Éś˝ÄŃoľĚ˝ßA
      zgÍ˘ë˘ëWX^ŞjółęénYcČńžŞB */
   if ( pkt_c != pkt_hit ) {
    assert( code_cmp != 0 );
    cnt = CALL_CMP64( code + code_cmp, pkt_hit->param64.hit,
                      pkt_c->param64.lr );
   } else {
    /* ć¤âŠXbhĹńšé */
    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 );
    }
   }
   /* qbgľ˝ĆŤĚ
      key ¨ćŃ lr Í pkt_c ÉvťčÍ pkt_hit ÉüÁÄ˘énY */
   xhash_loaded = 0;
   for ( kk = 0; kk < N_ALU; kk++ ) {
    ALU_T t;
    static uint64_t xhash[64];
    if ( special
#ifdef REON
         || regExpStr[0] != '\0'
#endif /* REON */
       ) {
     CALL_TR64( &pkt_c->param64.lr[0][0].q[kk / (N_ALU / N_Q)], xhash );
     xhash_loaded = 1;
    }
    if ( !(kk & (N_ALU / N_Q - 1)) ) nblk_total++, xhash_loaded = 0;
    if ( special
#ifdef REON
         || regExpStr[0] != '\0'
#endif /* REON */
       ) {
     char hash[16];
     FILE       *lfp;
     unsigned char      kind[3];
     for ( k = 0; k < ALU_BITS; k++ ) {
      for ( i = 1; i < 11; i++ ) {
       unsigned c = 0;
       c = (xhash[(ALU_BITS * kk + k) & 63] >> (6 * (i - 1))) & 0x3F;
       hash[i - 1] = C64[c];
      }
      hash[10] = 0;
#ifdef REON
      if ( regExpStr[0] != '\0' ) {
       if ( regexec( &regExp, hash, (size_t)0, NULL, 0 ) == 0 ) {
        if ( cr ) fprintf( stderr, "\n" );
        cr = 0;
#ifdef NAMA
        hit( rfp, hash, pkt_c->uk.key, kk, k, "ł", MAKAI_FALSE );
#else /* NAMA */
        hit( rfp, hash, pkt_c->uk.key, kk, k, "ł", MAKAI_TRUE );
#endif /* NAMA */
       }
      }
#endif /* REON */
      if ( special ) {
       if ( (lfp = checkSpecial( hash, kind )) != NULL ) {
        if ( cr ) fprintf( stderr, "\n" );
        cr = 0;
#ifdef NAMA
        hit( lfp, hash, pkt_c->uk.key, kk, k, kind, MAKAI_FALSE );
#else /* NAMA */
        hit( lfp, hash, pkt_c->uk.key, kk, k, kind, MAKAI_TRUE );
#endif /* NAMA */
       }
      }
     }
    }

    t = pkt_hit->param64.hit[HIT_ANY].a[kk];
    if ( !t ) continue;
    nap_total += ALU_BITS;
    for ( k = 0; k < ALU_BITS; k++ ) {
     char hash[16];
     int        hitLen;
     if ( !(t & ((ALU_T)1 << k)) ) continue;
     nap_hit++;
     /* ]u */
     if ( !xhash_loaded ) {
      nblk_hit++;
      CALL_TR64( &pkt_c->param64.lr[0][0].q[kk / (N_ALU / N_Q)], xhash );
      xhash_loaded = 1;
     }
     /* Ťđ˛×é */
     hitLen = 0;
     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;
     for ( i = 1; i < 11; i++ ) {
      unsigned c;
      c = (xhash[(ALU_BITS * kk + k) & 63] >> (6 * (i - 1))) & 0x3F;
      hash[i - 1] = C64[c];
     }
     hash[10] = 0;
     if ( cr ) fprintf( stderr, "\n" );
     cr = 0;
{
     unsigned char      len[10];
#ifdef SELF
     static hitCount = 0;
#endif /* SELF */

     sprintf( len, "%02d", hitLen );
     if ( hitLen < 10 ) {
      /* ˝Ü˝ÜăëÉćŘčśŞt˘˝ęAęÚđ E Éˇé */
      if ( hash[hitLen] == '.' || hash[hitLen] == '/' ) {
       len[0] = 'E';
      }
     }

#if SEQ > 0 /* žŞľŠľASEQ == 8 ĚęľŠlŚÄČ˘ */
     /* AmĚű@đżáńĆÇ˘ŠŻé×ŤžŞAßńÇł˘ĚĹąęĹ */
     if ( hitLen == 0 ) [
      char      ref;
      ref = hash[2];
      if ( ref == hash[3] && ref == hash[4] && ref == hash[5] &&
           ref == hash[6] && ref == hash[7] ) {
       if ( ref == hash[0] && ref == hash[1] ) {
        strcpy( len, "" );
       }
       if ( ref == hash[1] && ref == hash[8] ) {
        strcpy( len, "" );
       }
       if ( ref == hash[8] && ref == hash[9] ) {
        strcpy( len, "" );
       }
      }
     }
#endif /* SEQ */

#ifdef NAMA
     hit( ofp, hash, pkt_c->uk.key, kk, k, len, MAKAI_FALSE );
#else /* NAMA */
     hit( ofp, hash, pkt_c->uk.key, kk, k, len, MAKAI_TRUE );
#endif /* NAMA */

#ifdef SELF
     hitCount++;
     if ( hitCount >= SELF_LIM_CNT ) {
      exit( 0 );
     }
#endif /* SELF */
}
    }
   }

   /* ŹxvŞ */
   status.loop += N_ALU * ALU_BITS;

/* -g IvVpĚR[hÍAWin32 pľŠČ˘ */
/* todo UNIX npR[hŕvéŠČ */
#if defined(WIN32)
   if ( sCnt >= YOUSUMI ) {
    lCnt++;
    if ( lCnt > lCntMax ) {
     Sleep( (DWORD)10 );
     lCnt = 0;
    }
   }
#endif /* WIN32 */

   if ( status.loop >= status.lastloop + upd_int
        && (curTime = usec()) != status.lastTime ) {
    uint64_t diffTime;
    int a, b, c;
    /* ĘZ(PĘ ktrips/sec) */
    diffTime = curTime - status.startTime;
#ifdef SELF
    if ( diffTime >= SELF_LIM_SEC ) {
     exit( 0 );
    }
#endif /* SELF */
    a = status.loop / ((1000 / USEC_SEC) * diffTime);
#ifdef BENCH
    if ( (diffTime / USEC_SEC) > (BENCH * 60) ) {
     fprintf( stderr, "\n%6dktrips/s\n", a );
     exit( 0 );
    }
#endif /* BENCH */
    /* ćÔ(PĘ trips/sec) */
    diffTime = curTime - status.lastTime;
    b = USEC_SEC * (status.loop - status.lastloop) / diffTime;
#if defined(WIN32)
    if ( gear != DEF_GEAR ) {
     if ( sCnt < YOUSUMI ) {
      if ( b > maxSpeed ) {
       maxSpeed = b;
       /* x = l/s * (gear / (10 - gear)) / 100 */
       lCntMax = maxSpeed / (N_ALU * ALU_BITS) * (gear * 1000 / (10 - gear)) / 100000;
       if ( lCntMax < 1 ) {
        lCntMax = 1;
       }
      }
      sCnt++;
     }
    }
#endif /* WIN32 */
    /* \Ş */
    c = UPDATE_INTERVAL * b;
    /* §żăŞčČÇAëˇŞ č upd_int ŞŹłˇŹ˝ĆŤÍ
       ˘ŤČčSâłš¸ 1 b(==b)ĂÂűĘłšéB */
    upd_int = ( upd_int + b < c ? upd_int + b : c );
    status.lastTime = curTime;
    status.lastloop = status.loop;
    fprintf( stderr, "%6dktrips/s [%6d.%03dktrips/s]\r",
             a, b / 1000, b % 1000 );
    cr++;
   }
  }

  return 0;
}

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