54   :  black_stand(key.getPieceStand()), white_stand(white_stand),
 
   55      distance(distance), key(key), same_board_list(same_board_list),
 
   57      child_count(0), read_count(0), written_count(0),
 
   58      visited(false), by_simulation(false),
 
   59      by_fixed_black(false), by_fixed_white(false),
 
   60      already_set_up(false),
 
   61      final(false), is_split(false),
 
   62      do_oracle_attack(true),
 
   64      rzone_move_generation(use_rzone_move_generation)
 
   93   for (
unsigned int i = pass_left; i < SIZE; i++)
 
  103   for (RecordList::iterator it = same_board_list->begin();
 
  104        it != same_board_list->end(); it++)
 
  106     if (&(*it) == 
this) 
continue;
 
  108     for (
size_t pass_left = 0; pass_left < SIZE; pass_left++)
 
  110       if (isDominatedByProofPieces<BLACK>(&(*it), pass_left))
 
  114         setResult<BLACK>(pass_left, it->getValue<
BLACK>(pass_left),
 
  115                          it->getBestMove<
BLACK>(pass_left), 
false, &ps);
 
  119       else if (isDominatedByProofPieces<WHITE>(&(*it), pass_left))
 
  123         setResult<WHITE>(pass_left, it->getValue<
WHITE>(pass_left),
 
  124                          it->getBestMove<
WHITE>(pass_left), 
false, &ps);
 
  129     for (
int pass_left = (
int)SIZE - 1; pass_left >= 0; pass_left--)
 
  131       if (isDominatedByDisproofPieces<BLACK>(&(*it), pass_left))
 
  135         setResult<BLACK>(pass_left, it->getValue<
BLACK>(pass_left),
 
  136                          it->getBestMove<
BLACK>(pass_left), 
false, &ps);
 
  140       else if (isDominatedByDisproofPieces<WHITE>(&(*it), pass_left))
 
  145         setResult<WHITE>(pass_left, it->getValue<
WHITE>(pass_left),
 
  146                          best_move, 
false, &ps);
 
  163     return  values<BLACK>()[i];
 
  165     return  values<WHITE>()[i];
 
  172   return getValueSlow(turn(), i);
 
  179   return value_before_final;
 
  187     return getBestMove<BLACK>(i);
 
  189     return getBestMove<WHITE>(i);
 
  197     return isByFixed<BLACK>();
 
  199     return isByFixed<WHITE>();
 
  207     return pdpieces<BLACK>()[pass_left];
 
  209     return pdpieces<WHITE>()[pass_left];
 
  221     setResult<BLACK>(
int i,
 
  228     setResult<WHITE>(
int i,
 
  256     isNtesuki<BLACK>(
int pass_left) 
const;
 
  260     isNtesuki<WHITE>(
int pass_left) 
const;
 
  264     setNtesuki<BLACK>(
int pass_left);
 
  268     setNtesuki<WHITE>(
int pass_left);
 
  272     hasTriedPropagatedOracle<BLACK>(
int pass_left) 
const;
 
  276     hasTriedPropagatedOracle<WHITE>(
int pass_left) 
const;
 
  280     triedPropagatedOracle<BLACK>(
int pass_left);
 
  284     triedPropagatedOracle<WHITE>(
int pass_left);
 
  288     useOld<BLACK>(
int pass_left) 
const;
 
  292     useOld<WHITE>(
int pass_left) 
const;
 
  296     setUseOld<BLACK>(
int pass_left, 
bool b);
 
  300     setUseOld<WHITE>(
int pass_left, 
bool b);
 
  304     getPDPieces<BLACK>(
int pass_left) 
const;
 
  308     getPDPieces<WHITE>(
int pass_left) 
const;
 
  312     setPDPieces<BLACK>(
int pass_left,
 
  316     setPDPieces<WHITE>(
int pass_left,
 
  321     isLoopWithPath<BLACK>(
int pass_left,
 
  325     isLoopWithPath<WHITE>(
int pass_left,
 
  330     setLoopWithPath<BLACK>(
int pass_left,
 
  335     setLoopWithPath<WHITE>(
int pass_left,
 
  340     getValueWithPath<BLACK>(
int max_pass_left, 
const PathEncoding path) 
const;
 
  344     getValueWithPath<WHITE>(
int max_pass_left, 
const PathEncoding pat) 
const;
 
  348     getValueOr<BLACK>(
int max_pass_left, 
const PathEncoding path,
 
  349                       IWScheme iwscheme) 
const;
 
  353     getValueOr<WHITE>(
int max_pass_left, 
const PathEncoding pat,
 
  354                       IWScheme iwscheme) 
const;
 
  358     getValueAnd<BLACK>(
int max_pass_left, 
const PathEncoding pat,
 
  359                        IWScheme iwscheme, PSScheme psscheme) 
const;
 
  363     getValueAnd<WHITE>(
int max_pass_left, 
const PathEncoding pat,
 
  364                        IWScheme iwscheme, PSScheme psscheme) 
const;
 
  370       os << 
"player:\t"  << record.
key.turn() << 
"\n" 
  371          << 
"visited:\t"  << record.
isVisited() << 
"\n" 
  372          << 
"distance:\t"  << record.
distance << 
"\n" 
  374          << record.
key << 
"\nBS" 
  381         os << i << 
" B\tmove(" 
  409         throw std::runtime_error(
"cannot parse string");
 
  433         throw std::runtime_error(
"cannot parse string");
 
  449         throw std::runtime_error(
"cannot parse string");
 
  472         throw std::runtime_error(
"cannot parse string");
 
  492         throw std::runtime_error(
"cannot parse string");
 
  520         throw std::runtime_error(
"cannot parse string");