3 #ifndef _NTESUKI_SEACHER_H 
    4 #define _NTESUKI_SEACHER_H 
   58       typedef std::vector<NtesukiRecord *> 
nodes_t;
 
  129       static const int NtesukiNotFound = -1;
 
  130       static const int ReadLimitReached = -2;
 
  131       static const int TableLimitReached = -3;
 
  133       static const unsigned int INITIAL_PROOF_LIMIT =
 
  135       static const unsigned int INITIAL_DISPROOF_LIMIT =
 
  145                            unsigned int proofLimit,
 
  146                            unsigned int disproofLimit,
 
  148                            const Move last_move);
 
  153                            unsigned int proofLimit,
 
  154                            unsigned int disproofLimit,
 
  156                            const Move last_move);
 
  160                                     unsigned int& best_proof,
 
  161                                     unsigned int& sum_disproof,
 
  162                                     unsigned int& second_proof,
 
  163                                     unsigned int& best_disproof,
 
  164                                     unsigned int& step_cost,
 
  166                                     const int pass_left);
 
  175                             unsigned int proofLimit,
 
  176                             unsigned int disproofLimit,
 
  178                             const Move last_move);
 
  185                              unsigned int proofLimit,
 
  186                              unsigned int disproofLimit,
 
  188                              const Move last_move);
 
  192                                      unsigned int& best_disproof,
 
  193                                      unsigned int& sum_proof,
 
  194                                      unsigned int& second_disproof,
 
  195                                      unsigned int& best_proof,
 
  196                                      unsigned int& step_cost,
 
  199                                      const Move last_move);
 
  208       template <Player T> 
void simulateSiblingsSuccess(
NtesukiRecord *record,
 
  211                                                        unsigned int& success_count,
 
  212                                                        unsigned int& total_count);
 
  218       template <Player T> 
void simulateSiblingsFail(
NtesukiRecord *record,
 
  221                                                     unsigned int& success_count,
 
  222                                                     unsigned int& total_count);
 
  226       template <Player T> 
void handleNonAttack(
NtesukiRecord *record,
 
  233                                             const Move last_move);
 
  237       template <Player T> 
void handleInterpose(
NtesukiRecord *record,
 
  246                       unsigned int table_limit,
 
  247                       volatile int *stop_flag,
 
  253                       int tsumero_cost = 0,
 
  254                       int tsumero_estimate = 0,
 
  255                       double gc_ratio = 0.33);
 
  259       template <Player T> 
int search();
 
  263         read_node_limit = rnl;
 
  264         if (attacker == 
BLACK)
 
  265           return search<BLACK>();
 
  267           return search<WHITE>();