17   threatmate_move = 
Move();
 
   18   attack_shadow.fill(
false);    
 
   21   move_candidate_exists[
BLACK] = king8Info(
BLACK).hasMoveCandidate<
WHITE>(*state);
 
   22   move_candidate_exists[
WHITE] = king8Info(
WHITE).hasMoveCandidate<
BLACK>(*state);
 
   24   checkmate_defender[
BLACK] = findCheckmateDefender(*state, 
BLACK);
 
   25   checkmate_defender[
WHITE] = findCheckmateDefender(*state, 
WHITE);
 
   28   if (state->hasChangedEffects())
 
   29     changed_effects = state->changedEffects(
alt(turn));
 
   31     changed_effects.invalidate();
 
   32   threatened[turn] = state->inCheck(turn)
 
   33     ? state->kingPiece(turn) : state->findThreatenedPiece(turn);
 
   34   threatened[
alt(turn)] = state->findThreatenedPiece(
alt(turn));
 
   37     possible_threatmate_ptype
 
   39     const Square king = state->kingSquare(
alt(state->turn()));
 
   40     const CArray<Direction,2> directions = {{ 
UUL, 
UUR }};
 
   43       if (state->pieceAt(knight_attack).isEmpty()
 
   44           && ! state->hasEffectAt(
alt(state->turn()), knight_attack)) {
 
   50       if (possible_threatmate_ptype & (1<<p))
 
   51         if (state->hasPieceOnStand(state->turn(), 
static_cast<Ptype>(p)))
 
   55   bookmove.fill(
Move());
 
   61   copy.copyFrom(*state);
 
   63   const Square king = state->kingSquare(
alt(turn));
 
   66   updatePinnedGenerals(
BLACK);
 
   67   updatePinnedGenerals(
WHITE);
 
   69   makePinOfLongPieces();
 
   73       king8_long_pieces.push_back(p);
 
   75   BlockLong::updateCache(*
this);
 
   76   if (! history->hasLastMove() || !history->lastMove().isNormal()) {
 
   78     last_add_effect = PieceMask();
 
   80     last_move_ptype5 = 
unpromote(history->lastMove().ptype());
 
   81     if (last_move_ptype5 == 
SILVER)
 
   82       last_move_ptype5 = 
GOLD;
 
   83     else if (last_move_ptype5 == 
KNIGHT)
 
   84       last_move_ptype5 = 
LANCE;
 
   85     else if (
isMajor(last_move_ptype5))
 
   87     last_add_effect = state->effectedMask(
alt(turn))
 
   88       & state->effectedChanged(
alt(turn));
 
   90   PatternCommon::updateCache(*
this); 
 
   93     static const BookInMemory& 
book = BookInMemory::instance();
 
   94     book.find(HashKey(*state), all);
 
   95     for (
size_t i=0; i<bookmove.size(); ++i)
 
  106   if (state->inCheck()) 
 
  108   for (
int i=0; i<40; ++i) {
 
  109     const Piece p = state->pieceOf(i);
 
  112     CArray<mask_t,2> long_effect = {{
 
  116     if (long_effect[0].none() || long_effect[1].none()) 
continue;
 
  117     CArray<Piece,2> attack_piece;
 
  119       attack_piece[0] = state->findLongAttackAt(p, 
U);
 
  120       attack_piece[1] = state->findLongAttackAt(p, 
D);
 
  122           && attack_piece[0].owner() != attack_piece[1].owner()) {
 
  123         pin_by_opposing_sliders.push_back(p);
 
  130       attack_piece[0] = state->findLongAttackAt(p, 
L);
 
  131       attack_piece[1] = state->findLongAttackAt(p, 
R);
 
  133           && attack_piece[0].owner() != attack_piece[1].owner()) {
 
  134         pin_by_opposing_sliders.push_back(p);
 
  141       attack_piece[0] = state->findLongAttackAt(p, 
UL);
 
  142       attack_piece[1] = state->findLongAttackAt(p, 
DR);
 
  144           && attack_piece[0].owner() != attack_piece[1].owner()) {
 
  145         pin_by_opposing_sliders.push_back(p);
 
  148       attack_piece[0] = state->findLongAttackAt(p, 
UR);
 
  149       attack_piece[1] = state->findLongAttackAt(p, 
DL);
 
  151           && attack_piece[0].owner() != attack_piece[1].owner()) {
 
  152         pin_by_opposing_sliders.push_back(p);
 
  162   const King8Info king8info = state.king8Info(king);
 
  163   const unsigned int spaces = king8info.
spaces();
 
  164   if (spaces == 0 || (spaces & (spaces-1)))
 
  166   const Square sq = state.kingSquare(king)
 
  168   assert(state.pieceAt(sq).isEmpty());
 
  169   if (state.countEffect(king, sq) != 2 || ! state.hasEffectAt(
alt(king), sq))
 
  172   drop_candidate &= 0xff00;
 
  173   drop_candidate += spaces;
 
  174   mask_t drop_ptype=mask_t::makeDirect
 
  176   while(drop_ptype.any()){
 
  178     if (state.hasPieceOnStand(
alt(king),ptype))
 
  179       return std::make_pair(state.findCheapAttack(king, sq), sq);
 
  187   exchange_pins[owner].clear();
 
  188   PieceMask attacked = state->piecesOnBoard(owner)
 
  189     & state->effectedMask(owner) & state->effectedMask(
alt(owner));
 
  190   while (attacked.any()) {
 
  191     const Piece p = state->pieceOf(attacked.takeOneBit());
 
  192     const int a = state->countEffect(
alt(owner), p.
square());
 
  193     const int d = state->countEffect(owner, p.
square());
 
  196     const Piece attack_p = state->findCheapAttack(
alt(owner), p.
square());
 
  197     const Piece support = state->findCheapAttack(owner, p.
square());
 
  203       directions &= directions-1;
 
  207       Piece tp = state->pieceAt(target);
 
  209         assert(state->hasEffectByPiece(support, target));
 
  210         if (state->countEffect(owner, target)
 
  211             <= state->countEffect(
alt(owner), target)+1
 
  212             - state->hasEffectByPiece(attack_p, target)
 
  214           exchange_pins[owner].push_back
 
  226   NumEffectState copy(state);
 
  238       (state, last_move.
ptypeO(), last_move.
to(), state.kingSquare(state.turn()))) {
 
  243     if (state.hasPieceOnStand<
GOLD>(
alt(state.turn()))) {
 
  255   for (
int x=1; x<=9; ++x) {
 
  256     for (
int y=1; y<=9; ++y) {
 
  257       const Square position(x,y);
 
  278     && HashKey(l.
copy) == HashKey(r.
copy);