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;