7 #include "osl/apply_move/applyMoveWithPath.h" 
   21 using namespace osl::ntesuki;
 
   31   if (record->getValueWithPath<A>(pass_left, path).proof() == 0)\ 
   32     ntesuki_assert(record->getValueWithPath<A>(pass_left, path).disproof() > ProofDisproof::DISPROOF_LIMIT);\ 
   33   if (record->getValueWithPath<A>(pass_left, path).disproof() == 0)\ 
   34     ntesuki_assert(record->getValueWithPath<A>(pass_left, path).proof() > ProofDisproof::PROOF_LIMIT);\ 
   35   ntesuki_assert(val.isFinal() == record->getValueWithPath<A>(pass_left, path).isFinal());\ 
   38 #define RETURN(val) return val 
   41 #define RETURN_ON_STOP \ 
   42   if (node_count > read_node_limit || *stop_flag)\ 
   50                                unsigned int l, 
unsigned int r)
 
   54   const unsigned int sum = l+r;
 
   99 template <
class Search,Player T>
 
  117                unsigned int proof_limit,
 
  118                unsigned int disproof_limit,
 
  119                unsigned int pass_left,
 
  120                const Move last_move)
 
  121     : proof_limit(proof_limit), disproof_limit(disproof_limit),
 
  122       pass_left(pass_left),
 
  123       searcher(searcher),  result(result), record(record),
 
  124       oracle_attack(oracle_attack), oracle_defense(oracle_defense),
 
  131     result = (*searcher).template defense<PlayerTraits<T>::opponent>
 
  132       (record, oracle_attack, oracle_defense,
 
  133        proof_limit, disproof_limit, pass_left, last_move);
 
  140 template <
class Search,Player T>
 
  158                        unsigned int pass_left,
 
  159                        bool& simulation_result,
 
  160                        const Move last_move)
 
  161     : simulator(simulator), table(table),
 
  162       record(record), record_orig(record_orig),
 
  163       pass_left(pass_left),
 
  164       simulation_result(simulation_result),
 
  172     simulation_result = simulator.template
 
  173       startFromDefenseDisproof<PlayerTraits<T>::opponent>
 
  174       (record, record_orig, pass_left, last_move);
 
  181 template <
class Search,Player T>
 
  200                 unsigned int proof_limit,
 
  201                 unsigned int disproof_limit,
 
  202                 unsigned int pass_left,
 
  203                 const Move last_move)
 
  204     : proof_limit(proof_limit), disproof_limit(disproof_limit),
 
  205       pass_left(pass_left), searcher(searcher), result(result), record(record),
 
  206       oracle_attack(oracle_attack), oracle_defense(oracle_defense),
 
  213     (*searcher).template attack<PlayerTraits<T>::opponent>
 
  214       (record,  oracle_attack, oracle_defense,
 
  215        proof_limit, disproof_limit,
 
  216        pass_left, last_move);
 
  223 template <
class Search,Player T>
 
  226 CallSimulationDefense
 
  240                         unsigned int pass_left,
 
  241                         bool& simulation_result,
 
  242                         const Move last_move)
 
  243     : simulator(simulator), table(table),
 
  244       record(record), record_orig(record_orig),
 
  245       pass_left(pass_left),
 
  246       simulation_result(simulation_result),
 
  254     simulation_result = simulator.template
 
  255       startFromAttackProof<PlayerTraits<T>::opponent>
 
  256       (record, record_orig, pass_left, last_move);
 
  263 template <
class Search,Player T>
 
  266 CallSimulationDefenseDisproof
 
  280                                 unsigned int pass_left,
 
  281                                 bool& simulation_result,
 
  282                                 const Move last_move)
 
  283     : simulator(simulator), table(table),
 
  284       record(record), record_orig(record_orig),
 
  285       pass_left(pass_left),
 
  286       simulation_result(simulation_result),
 
  294     simulation_result = simulator.template
 
  295       startFromAttackDisproof<PlayerTraits<T>::opponent>
 
  296       (record, record_orig, pass_left, last_move);
 
  305                      unsigned int& success_count,
 
  306                      unsigned int& total_count)
 
  311   if (!record_best) 
return;
 
  315   mg->generate<T>(state, 
moves);
 
  317   for (NtesukiMoveList::iterator move_it = moves.begin();
 
  318        move_it != moves.end(); move_it++)
 
  323     if (record_child == 0)
 
  325       *stop_flag = TableLimitReached;
 
  329     if (record_child == record_best) 
continue;
 
  335     if (result_child.isFinal())
 
  340     bool simulation_result;
 
  343       helper(simulator, table, record_child, record_best,
 
  344              pass_left, simulation_result, move.
getMove());
 
  346     ApplyMoveWithPath<T>::doUndoMoveOrPass(state, path, move.
getMove(), helper);
 
  350     if (simulation_result)
 
  371     : record(r), table(t)
 
  373     size_start = table.size();
 
  378     record->addChildCount(table.size() - size_start);
 
  395        unsigned int proof_limit, 
unsigned int disproof_limit,
 
  396        const int pass_left, 
const Move last_move)
 
  447   while ((result_cur.
proof() < proof_limit) &&
 
  448          (result_cur.
disproof() < disproof_limit))
 
  450     if (iwscheme == NtesukiRecord::no_iw)
 
  455       attackWithOrder<T>(record, NULL, NULL,
 
  456                          proof_limit, disproof_limit,
 
  457                          pass_left, last_move);
 
  462     else if (iwscheme == NtesukiRecord::strict_iw)
 
  466       for (
int pass_left_child = 0; pass_left_child <= pass_left; pass_left_child++)
 
  474           attackWithOrder<T>(record, NULL, NULL,
 
  475                              proof_limit, disproof_limit,
 
  476                              pass_left_child, last_move);
 
  484     else if (iwscheme == NtesukiRecord::pn_iw)
 
  490       int pass_left_best = -1;
 
  491       for (
int pass_left_child = 0; pass_left_child <= pass_left; pass_left_child++)
 
  496         const unsigned int proof = result_st.
proof();
 
  499           pass_left_best = pass_left_child;
 
  503         else if (proof < p_2nd)
 
  509       unsigned int proof_limit_child = 
std::min(proof_limit, p_2nd + 1);
 
  510       unsigned int disproof_limit_child = disproof_limit;
 
  512       attackWithOrder<T>(record, NULL, NULL,
 
  513                          proof_limit_child, disproof_limit_child,
 
  514                          pass_left_best, last_move);
 
  519     result_cur = record->
getValueOr<A>(pass_left, path, iwscheme);
 
  529                 unsigned int proof_limit, 
unsigned int disproof_limit,
 
  530                 const int pass_left, 
const Move last_move)
 
  544   const bool under_attack = state.inCheck(T);
 
  568     ++attack_node_under_attack_count;
 
  570   attack_node_moves_count += moves.size();
 
  575     if (pass_left != 0 &&
 
  587                              NtesukiMove::INVALID(), 
false);
 
  596                              NtesukiMove::INVALID(), 
false);
 
  606                          NtesukiMove::INVALID(), 
false);
 
  626     unsigned int step_cost = 1;
 
  629       selectMoveAttack<T>(record,
 
  630                           best_proof, sum_disproof,
 
  631                           second_proof, best_disproof,
 
  635     if (best_move == NULL)
 
  637       if (pass_left != 0 &&
 
  638           record->rzone_move_generation)
 
  641         NtesukiResult r = record->getValueWithPath<A>(pass_left - 1, path);
 
  646           record->rzone_move_generation = 
false;
 
  649                                NtesukiMove::INVALID(), 
false);
 
  658                                NtesukiMove::INVALID(), 
false);
 
  664         ntesuki_assert(record->getValueWithPath<A>(pass_left, path).disproof() == 0);
 
  676     record->setResult<A>(pass_left, result_cur,
 
  677                          NtesukiMove::INVALID(), 
false);
 
  681     if ((proof_limit <= best_proof) ||
 
  682         (disproof_limit <= sum_disproof))
 
  690     unsigned int proof_child = 
std::min(proof_limit, second_proof + step_cost);
 
  692     unsigned int disproof_child =
 
  694                         disproof_limit, best_disproof)
 
  697     NtesukiRecord *record_child = table.allocateWithMove(record, *best_move);
 
  698     if (record_child == 0)
 
  700       *stop_flag = TableLimitReached;
 
  707     if (!result_child.isFinal())
 
  711         oracle_attack = NULL;
 
  715           record->getValueWithPath<A>(pass_left - 1, path).isCheckmateFail())
 
  717         oracle_defense = record;
 
  731       ApplyMoveWithPath<T>::doUndoMoveOrPass(state, path, best_move->
getMove(), helper);
 
  733       record->updateWithChild(record_child, pass_left);
 
  736       const NtesukiResult result_cur = record->getValueWithPath<A>(pass_left, path_child);
 
  743     if (result_child.isPawnDropFoul(best_move->
getMove()))
 
  748     else if (result_child.isCheckmateSuccess())
 
  757     else if (result_child.isCheckmateFail())
 
  769       if (ptt_siblings_fail &&
 
  774         simulateSiblingsFail<T>(record, record_child, pass_left,
 
  775                                 sibling_attack_success_count,
 
  776                                 sibling_attack_count);
 
  784 typedef std::pair<unsigned int, unsigned int> 
top_pdp_t;
 
  788   if (lhs.first == rhs.first)
 
  791     return rhs.second < rhs.second;
 
  795     return lhs.first > rhs.first;
 
  802                  unsigned int& best_proof,
 
  803                  unsigned int& sum_disproof,
 
  804                  unsigned int& second_proof,
 
  805                  unsigned int& best_disproof,
 
  806                  unsigned int& step_cost,
 
  812   bool read_nopromote = 
false;
 
  814  re_select_move_attack:
 
  818   bool pawn_checkmate = 
false;
 
  819   unsigned short min_child_age = SHRT_MAX;
 
  821   int average_cost = 0;
 
  822   int average_cost_count = 0;
 
  831   std::list<top_pdp_t> pdps;
 
  835   for (NtesukiMoveList::iterator move_it = moves.begin();
 
  836        move_it != moves.end(); ++move_it)
 
  846     if (!move.
isCheck() && 0 == pass_left)
 
  856     if (delay_nopromote &&
 
  863     if (delay_non_attack &&
 
  875     if (tsumero_estimate && !move.
isCheck())
 
  877       proof = tsumero_estimate;
 
  881     average_cost += proof;
 
  882     average_cost_count++;
 
  884     NtesukiRecord *record_child = table.findWithMove(record, move);
 
  900         record_child->
getValueAnd<A>(pass_left, path_child,
 
  903       proof = result_child.proof();
 
  904       disproof = result_child.disproof();
 
  917           pawn_checkmate = 
true;
 
  930             isPawnDropFoul(move.
getMove()))
 
  934           pawn_checkmate = 
true;
 
  953         if (!record->
useOld<A>(pass_left))
 
  969       proof += tsumero_cost;
 
  970       disproof += tsumero_cost;
 
  973     if (!record->
useOld<A>(pass_left)
 
  974         && !(NtesukiRecord::max_for_split && record->
is_split))
 
  977                                        disproof, sum_disproof);
 
  981       sum_disproof = 
std::max(disproof, sum_disproof);
 
  985     if (proof < best_proof)
 
  988       second_proof = best_proof;
 
  990       best_disproof = disproof;
 
  992     else if (proof < second_proof)
 
  994       second_proof = proof;
 
  998     if (dynamic_widening_width > 0)
 
 1000       if (pdps.size() < dynamic_widening_width)
 
 1002         pdps.push_back(
top_pdp_t(proof, disproof));
 
 1008         if (pdps.back().first > proof)
 
 1011           pdps.push_back(
top_pdp_t(proof, disproof));
 
 1019   if ((dynamic_widening_width > 0 &&
 
 1020        dynamic_widening_width < moves.size())
 
 1022       (!record->
useOld<A>(pass_left)
 
 1023        && !(NtesukiRecord::max_for_split && record->
is_split)))
 
 1026     for (std::list<top_pdp_t>::const_iterator it = pdps.begin();
 
 1027          it != pdps.end(); ++it)
 
 1029       sum_disproof += it->second;
 
 1035   if (best_move == NULL)
 
 1037     if (
false == record->
useOld<A>(pass_left))
 
 1039       if (SHRT_MAX != min_child_age)
 
 1046         goto re_select_move_attack;
 
 1052       if (!read_attack_only)
 
 1055         if (ptt_non_attack &&
 
 1059           handleNonAttack<T>(record, pass_left);
 
 1064         goto re_select_move_attack;
 
 1068     if (delay_nopromote &&
 
 1070         (pass_left > 0 || pawn_checkmate))
 
 1072       read_nopromote = 
true;
 
 1074       goto re_select_move_attack;
 
 1079     if (pass_left != 0 &&
 
 1088       if (delay_nopromote) assert(read_nopromote);
 
 1092                            NtesukiMove::INVALID(), 
false);
 
 1102                            NtesukiMove::INVALID(), 
false);
 
 1110                            NtesukiMove::INVALID(), 
false);
 
 1121   if (record->
useOld<A>(pass_left))
 
 1126   average_cost /= average_cost_count;
 
 1127   step_cost = 
std::max(average_cost, 1);
 
 1140   mg->generate<T>(state, 
moves);
 
 1142   for (NtesukiMoveList::iterator move_it = moves.begin();
 
 1143        move_it != moves.end(); ++move_it)
 
 1147     const PathEncoding path_best(path, move_it->getMove());
 
 1153     for (NtesukiMoveList::iterator move_it2 = moves.begin();
 
 1154          move_it2 != moves.end(); ++move_it2)
 
 1156       if (move_it2->isPass())
 
 1160       if (*move_it2 == *move_it)
 
 1164       if (move_it2->isCheckmateFail<A>(pass_left))
 
 1168       NtesukiRecord *record_child = table.allocateWithMove(record,
 
 1170       if (record_child == 0)
 
 1172         *stop_flag = TableLimitReached;
 
 1176       const PathEncoding path_child(path, move_it->getMove());
 
 1186         move_it2->setCheckmateFail<A>(pass_left);
 
 1192       bool simulation_result;
 
 1194         helper(simulator, table, record_child, record_best,
 
 1195                pass_left, simulation_result, move_it2->getMove());
 
 1197       ApplyMoveWithPath<T>::doUndoMoveOrPass(state, path, move_it2->getMove(), helper);
 
 1201       if (simulation_result)
 
 1203         move_it2->setBySimulation();
 
 1204         move_it2->setCheckmateFail<A>(pass_left);
 
 1218         unsigned int proof_limit, 
unsigned int disproof_limit,
 
 1220         const Move last_move)
 
 1230                                          iwscheme, psscheme).
proof()
 
 1241                                          iwscheme, psscheme));
 
 1271   while ((result_cur.
proof() < proof_limit) &&
 
 1272          (result_cur.
disproof() < disproof_limit))
 
 1274     bool read_attack_first = 
false;
 
 1287           record->
getValueOr<D>(pass_left - 1, path, iwscheme);
 
 1288         if (result_defender.proof() < result_attacker.
disproof())
 
 1290           read_attack_first = 
true;
 
 1295     if (read_attack_first)
 
 1300       attack<T>(record, NULL, NULL,
 
 1301                 disproof_limit, proof_limit,
 
 1302                 pass_left - 1, last_move);
 
 1309       defenseWithPlayer<T>(record, oracle_attack, oracle_defense,
 
 1310                            proof_limit, disproof_limit,
 
 1311                            pass_left, last_move);
 
 1315     result_cur = record->
getValueAnd<A>(pass_left, path, iwscheme, psscheme);
 
 1325                   unsigned int proof_limit, 
unsigned int disproof_limit,
 
 1327                   const Move last_move)
 
 1330   const bool under_attack = state.inCheck(T);
 
 1344                          NtesukiMove::INVALID(), 
false);
 
 1350   ++defense_node_count;
 
 1353     ++defense_node_under_attack_count;
 
 1355   defense_node_moves_count += moves.size();
 
 1361   if (!under_attack &&
 
 1370     if (record_pass == 0)
 
 1372       *stop_flag = TableLimitReached;
 
 1384                            NtesukiMove::INVALID(), 
false);
 
 1393     if (!result_pass.isFinal())
 
 1395       bool simulation_result;
 
 1397         helper(simulator, table, record_pass, oracle_defense,
 
 1398                pass_left - 1, simulation_result, pass.
getMove());
 
 1400       ApplyMoveWithPath<T>::doUndoMoveOrPass(state, path, pass.
getMove(), helper);
 
 1404       if (simulation_result)
 
 1424     if (record_pass == 0)
 
 1426       *stop_flag = TableLimitReached;
 
 1438                            NtesukiMove::INVALID(), 
false);
 
 1447     if (!result_pass.isFinal())
 
 1449       ++isshogi_attack_count;
 
 1451       bool simulation_result;
 
 1453         helper(simulator, table, record_pass, oracle_attack,
 
 1454                pass_left - 1, simulation_result, pass.
getMove());
 
 1456       ApplyMoveWithPath<T>::doUndoMoveOrPass(state, path, pass.
getMove(), helper);
 
 1460       if (simulation_result)
 
 1462         ++isshogi_attack_success_count;
 
 1469         if (ptt_invalid_defense)
 
 1472           simulateSiblingsSuccess<T>(record, record_pass, pass_left,
 
 1489     unsigned int step_cost = 1;
 
 1492     best_move = selectMoveDefense<T>(record,
 
 1502     if (NULL == best_move)
 
 1505                      isCheckmateSuccess());
 
 1508     else if (best_disproof == 0)
 
 1511                      record->isLoopWithPath<A>(pass_left, path));
 
 1517       NtesukiRecord* best_child = table.findWithMove(record, *best_move);
 
 1521         int pass_left_child = pass_left;
 
 1522         if (best_move->
isPass()) --pass_left_child;
 
 1524           best_child->
getValueOr<A>(pass_left_child, path_child,iwscheme);
 
 1534     record->setResult<A>(pass_left, result_cur,
 
 1535                          NtesukiMove::INVALID(), 
false);
 
 1539     if ((disproof_limit <= best_disproof) ||
 
 1540         (proof_limit <= sum_proof))
 
 1546     unsigned int proof_child =
 
 1548                         proof_limit, best_proof) - sum_proof;
 
 1549     unsigned int disproof_child = 
std::min(disproof_limit,
 
 1550                                            second_disproof + step_cost);
 
 1554     int pass_left_child = pass_left;
 
 1560       table.allocateWithMove(record, *best_move);
 
 1561     if (record_child == 0)
 
 1563       *stop_flag = TableLimitReached;
 
 1585           oracle_attack = table.findWithMove(record, pass);
 
 1590       if (result_child.
proof() >= proof_child)
 
 1592         std::cerr << *record_child
 
 1593                   << result_child << 
"<- result \n" 
 1594                   << proof_child << 
"/" << disproof_child << 
"<- limit\n" 
 1595                   << *best_move << 
"\n" 
 1596                   << sum_proof << 
"/" << best_disproof << 
" <- cur\n";
 
 1611         NtesukiRecord::pass_count++;
 
 1614       ApplyMoveWithPath<T>::doUndoMoveOrPass(state, path, best_move->
getMove(), helper);
 
 1619         NtesukiRecord::pass_count--;
 
 1621       record->updateWithChild(record_child, pass_left);
 
 1624       if (record->getValueWithPath<A>(pass_left, path).isFinal())
 
 1636         ++disproof_by_inversion_count;
 
 1640         record->setLoopWithPath<A>(pass_left, path);
 
 1643                              NtesukiMove::INVALID(), 
false);
 
 1650       record->setResult<A>(pass_left, result_child,
 
 1658       NtesukiRecord *best_record = table.findWithMove(record, *best_move);
 
 1659       if ((ptt_invalid_defense && best_move->
isPass()) ||
 
 1660           (ptt_siblings_success && !best_move->
isCheck())
 
 1664         simulateSiblingsSuccess<T>(record, best_record, pass_left,
 
 1665                                    sibling_defense_success_count,
 
 1666                                    sibling_defense_count);
 
 1677                   unsigned int& best_disproof,
 
 1678                   unsigned int& sum_proof,
 
 1679                   unsigned int& second_disproof,
 
 1680                   unsigned int& best_proof,
 
 1681                   unsigned int& step_cost,
 
 1683                   const int pass_left,
 
 1684                   const Move last_move)
 
 1687   const bool under_attack = state.inCheck(T);
 
 1693   bool read_non_pass = under_attack;
 
 1694   if (pass_left > 0 && !under_attack)
 
 1697     NtesukiRecord *record_pass = table.findWithMove(record, pass);
 
 1703                                          path_child).isCheckmateSuccess();
 
 1709   if (isscheme == NtesukiRecord::normal_is)
 
 1711     read_check_defense = 
true;
 
 1714  re_select_move_defense:
 
 1715   unsigned short min_child_age = SHRT_MAX;
 
 1718   int average_cost = 0;
 
 1719   int average_cost_count = 0;
 
 1728   std::list<top_pdp_t> pdps;
 
 1732   for (NtesukiMoveList::iterator move_it = moves.begin();
 
 1733        move_it != moves.end(); ++move_it)
 
 1742     if (delay_non_pass &&
 
 1749     if (delay_interpose &&
 
 1759         !read_check_defense)
 
 1767     average_cost += disproof;
 
 1768     average_cost_count++;
 
 1770     NtesukiRecord *record_child = table.findWithMove(record, move);
 
 1773       int pass_left_child = pass_left;
 
 1774       if (move.
isPass()) --pass_left_child;
 
 1779         record_child->
getValueOr<A>(pass_left_child, path_child,
 
 1790                              NtesukiMove::INVALID(), 
false);
 
 1796       proof    = result_child.proof();
 
 1797       disproof = result_child.disproof();
 
 1799       if (result_child.isCheckmateSuccess())
 
 1808           if (ptt_invalid_defense)
 
 1811             simulateSiblingsSuccess<T>(record, record_child, pass_left,
 
 1816             goto re_select_move_defense;
 
 1819         if (ptt_siblings_success && !move.
isCheck())
 
 1822           simulateSiblingsSuccess<T>(record, record_child, pass_left,
 
 1823                                      sibling_defense_success_count,
 
 1824                                      sibling_defense_count);
 
 1828           goto re_select_move_defense;
 
 1832       else if (result_child.isCheckmateFail())
 
 1834         if (move.
isCheck() && read_check_defense)
 
 1836           ++disproof_by_inversion_count;
 
 1843                                NtesukiMove::INVALID(), 
false);
 
 1852         record->
setResult<A>(pass_left, result_child,
 
 1859       min_child_age = 
std::min(min_child_age,
 
 1864         if (!record->
useOld<A>(pass_left))
 
 1872     if (record->
useOld<A>(pass_left))
 
 1874       sum_proof = 
std::max(proof, sum_proof);
 
 1876     else if (NtesukiRecord::max_for_split && record->
is_split)
 
 1878       sum_proof = 
std::max(proof, sum_proof);
 
 1886     if (disproof < best_disproof)
 
 1889       second_disproof = best_disproof;
 
 1890       best_disproof = disproof;
 
 1893     else if (disproof < second_disproof)
 
 1895       second_disproof = disproof;
 
 1899     if (dynamic_widening_width > 0)
 
 1901       if (pdps.size() < dynamic_widening_width)
 
 1903         pdps.push_back(
top_pdp_t(disproof, proof));
 
 1908         if (pdps.back().first > disproof)
 
 1911           pdps.push_back(
top_pdp_t(disproof, proof));
 
 1919   if (dynamic_widening_width > 0 &&
 
 1920        dynamic_widening_width < moves.size())
 
 1923     for (std::list<top_pdp_t>::const_iterator it = pdps.begin();
 
 1924          it != pdps.end(); ++it)
 
 1926       sum_proof += it->second;
 
 1932   if (NULL == best_move)
 
 1936     if (delay_non_pass &&
 
 1937         read_non_pass == 
false)
 
 1941       read_non_pass = 
true;
 
 1945       if (ptt_invalid_defense)
 
 1949         NtesukiRecord *record_pass = table.findWithMove(record, move_pass);
 
 1953                                                         path_child).isCheckmateSuccess());
 
 1955         simulateSiblingsSuccess<T>(record, record_pass, pass_left,
 
 1961       goto re_select_move_defense;
 
 1964     if (!record->
useOld<A>(pass_left))
 
 1966       if (SHRT_MAX != min_child_age)
 
 1973         goto re_select_move_defense;
 
 1977     if (delay_interpose &&
 
 1978         read_interpose == 
false)
 
 1980       read_interpose = 
true;
 
 1984       handleInterpose<T>(record, pass_left);
 
 1988       goto re_select_move_defense;
 
 1994     case NtesukiRecord::no_is:
 
 1997     case NtesukiRecord::tonshi_is:
 
 1998       handleTonshi<T>(record, pass_left, last_move);
 
 2001     case NtesukiRecord::delay_is:
 
 2002       if (read_check_defense == 
false)
 
 2004         ++proof_without_inversion_count;
 
 2005         read_check_defense = 
true;
 
 2006         record->setReadCheckDefense(pass_left);
 
 2007         goto re_select_move_defense;
 
 2010     case NtesukiRecord::normal_is:
 
 2018                          NtesukiMove::INVALID(), 
false);
 
 2026   if (record->
useOld<A>(pass_left))
 
 2031   average_cost /= average_cost_count;
 
 2032   step_cost = 
std::max(average_cost, 1);
 
 2040              const Move last_move)
 
 2049     if (!result_defender.
isFinal())
 
 2054                            NtesukiMove::INVALID(), 
false);
 
 2055       const unsigned int read_node_limit_orig = read_node_limit;
 
 2060       else if ((record->
distance / 2) == 1)
 
 2067       result_defender = attack<T>(record, NULL, NULL,
 
 2068                                   INITIAL_PROOF_LIMIT, INITIAL_PROOF_LIMIT,
 
 2069                                   pass_left - 1, last_move);
 
 2074         ++attack_back_count;
 
 2077       read_node_limit = read_node_limit_orig;
 
 2081     if (result_defender.
isFinal())
 
 2093                         unsigned int& success_count,
 
 2094                         unsigned int& total_count)
 
 2099   if (!record_best) 
return;
 
 2104   mg->generate<T>(state, 
moves);
 
 2106   for (NtesukiMoveList::iterator move_it = moves.begin();
 
 2107        move_it != moves.end(); ++move_it)
 
 2110     NtesukiRecord *record_child = table.allocateWithMove(record,
 
 2112     if (record_child == 0)
 
 2114       *stop_flag = TableLimitReached;
 
 2118     if (record_child == record_best) 
continue;
 
 2119     if (record_child->
isVisited()) 
continue;
 
 2125     if (result_child.isFinal())
 
 2130     bool simulation_result;
 
 2133       helper(simulator, table, record_child, record_best,
 
 2134              pass_left, simulation_result, move.
getMove());
 
 2136     ApplyMoveWithPath<T>::doUndoMoveOrPass(state, path, move.
getMove(), helper);
 
 2140     if (simulation_result)
 
 2160   mg->generate<T>(state, 
moves);
 
 2162   for (NtesukiMoveList::iterator move_it = moves.begin();
 
 2163        move_it != moves.end(); ++move_it)
 
 2165     if (move_it->isInterpose() &&
 
 2166         !move_it->isCheckmateSuccess<A>(pass_left))
 
 2168       NtesukiRecord *record_child = table.allocateWithMove(record,
 
 2170       if (record_child == 0)
 
 2172         *stop_flag = TableLimitReached;
 
 2177       const PathEncoding path_child(path, move_it->getMove());
 
 2185       NtesukiMoveList::iterator best_it = moves.begin();
 
 2186       for (; best_it != moves.end(); ++best_it)
 
 2188         if (best_it->to() == move_it->to() &&
 
 2189             best_it->isCheckmateSuccess<A>(pass_left)) 
break;
 
 2191       if (best_it == moves.end())
 
 2195       const NtesukiRecord* record_best = table.findWithMove(record, *best_it);
 
 2198       bool simulation_result;
 
 2200         helper(simulator, table, record_child, record_best,
 
 2201                pass_left, simulation_result, move_it->getMove());
 
 2203       ApplyMoveWithPath<T>::doUndoMoveOrPass(state, path, move_it->getMove(), helper);
 
 2207       if (simulation_result)
 
 2209         move_it->setBySimulation();
 
 2210         move_it->setCheckmateSuccess<A>(pass_left);
 
 2226   NtesukiRecord::pass_count = 0;
 
 2229   const HashKey key(state);  
 
 2236   if (A == state.turn())
 
 2239     result = attack<T>(record, NULL, NULL,
 
 2240                        INITIAL_PROOF_LIMIT,
 
 2241                        INITIAL_DISPROOF_LIMIT,
 
 2247     if (0 == (max_pass - 1) &&
 
 2250       if (
verbose) std::cerr << 
"No Check" << std::endl;
 
 2251       return NtesukiNotFound;
 
 2255       result = defense<T>(record, NULL, NULL,
 
 2256                           INITIAL_PROOF_LIMIT,
 
 2257                           INITIAL_DISPROOF_LIMIT,
 
 2263   if (node_count > read_node_limit || *stop_flag)
 
 2265     if (
verbose) std::cerr << 
"Limit Reached\t" << result << std::endl;
 
 2266     return ReadLimitReached;
 
 2270     if (
verbose) std::cerr << 
"result:\t" << result << std::endl;
 
 2273       for (
unsigned int i = 0; i < max_pass; ++i)
 
 2284   return NtesukiNotFound;