12   : move(
Move::INVALID()), flags(0), 
order(-1)  {};
 
   16   : move(m), flags(0), 
order(-1),
 
   17     h_a_proof(1), h_a_disproof(1),
 
   18     h_d_proof(1), h_d_disproof(1)
 
   23   : move(m), flags(f), 
order(-1),
 
   24     h_a_proof(1), h_a_disproof(1),
 
   25     h_d_proof(1), h_d_disproof(1)
 
   30   : move(m.move), flags(m.flags), 
order(m.
order),
 
   31     h_a_proof(1), h_a_disproof(1),
 
   32     h_d_proof(1), h_d_disproof(1)
 
   39   if (
this == &m) 
return *
this;
 
   72   return flags & CHECK_FLAG;
 
   99   return flags & NOPROMOTE;
 
  112   return flags & INTERPOSE;
 
  125   return flags & LAME_LONG;
 
  131   flags |= TO_OLDER_CHILD;
 
  137   return flags & TO_OLDER_CHILD;
 
  146   return flags & IMMEDIATE_CHECKMATE;
 
  152   flags |= BY_SIMULATION;
 
  158   return flags & BY_SIMULATION;
 
  166   flags |= PAWN_DROP_CHECKMATE_FLAG;
 
  172   return        (flags & PAWN_DROP_CHECKMATE_FLAG) == PAWN_DROP_CHECKMATE_FLAG;
 
  177               unsigned short p_d, 
unsigned short d_d)
 
  189     return isCheckmateSuccess<BLACK>(pass_left);
 
  191     return isCheckmateSuccess<WHITE>(pass_left);
 
  198     return isCheckmateFail<BLACK>(pass_left);
 
  200     return isCheckmateFail<WHITE>(pass_left);
 
  215 to()
 const { 
return move.to(); }
 
  217 ptype()
 const { 
return move.ptype(); }
 
  225   return move == rhs.
move;
 
  230   return move != rhs.
move;
 
  238   for (
int i = 0; i < 32; ++i)
 
  250   os << 
"o=" << move.
getOrder() << 
" ";
 
  259     template void NtesukiMove::setCheckmateSuccess<BLACK>(
int pass_left);
 
  260     template void NtesukiMove::setCheckmateSuccess<WHITE>(
int pass_left);
 
  261     template void NtesukiMove::setCheckmateFail<BLACK>(
int pass_left);
 
  262     template void NtesukiMove::setCheckmateFail<WHITE>(
int pass_left);
 
  263     template void NtesukiMove::setImmediateCheckmate<BLACK>();
 
  264     template void NtesukiMove::setImmediateCheckmate<WHITE>();