27   return cloneIt(*
this);
 
   33   const MilliSeconds::Interval consumed
 
   34     = setUpTable(gs, pawnValueOfTurn<AlphaBeta2ProgressEval>(gs.
state().turn()));
 
   42   catch (std::bad_alloc&)
 
   44     std::cerr << 
"panic. allocation of AlphaBeta2 failed\n";
 
   46   return SearchPlayer::search<AlphaBeta2ProgressEval>(gs, msec);
 
   51                                    Move move, 
int pawn_sacrifice)
 
   53   setUpTable(gs, pawnValueOfTurn<AlphaBeta2ProgressEval>(gs.
state().turn()));
 
   56   return SearchPlayer::isReasonableMoveBySearch(searcher, move, pawn_sacrifice);
 
   75   return cloneIt(*
this);
 
   81   const MilliSeconds::Interval consumed = setUpTable(gs, pawnValueOfTurn<AlphaBeta2OpenMidEndingEval>(gs.
state().turn()));
 
   89   catch (std::bad_alloc&)
 
   91     std::cerr << 
"panic. allocation of AlphaBeta2 failed\n";
 
   93   return SearchPlayer::search<AlphaBeta2OpenMidEndingEval>(gs, msec);
 
  101     result = searchWithSecondsForThisMove(gs, org);
 
  108                                    Move move, 
int pawn_sacrifice)
 
  110   setUpTable(gs, pawnValueOfTurn<AlphaBeta2OpenMidEndingEval>(gs.
state().turn()));
 
  113   return SearchPlayer::isReasonableMoveBySearch(searcher, move, pawn_sacrifice);
 
  132   return cloneIt(*
this);
 
  138   const MilliSeconds::Interval consumed = setUpTable(gs, pawnValueOfTurn<AlphaBeta3>(gs.
state().turn()));
 
  143     searcher.reset(
new AlphaBeta3(gs.
state(), *checkmate_ptr, table_ptr.get(),
 
  146   catch (std::bad_alloc&)
 
  148     std::cerr << 
"panic. allocation of AlphaBeta3 failed\n";
 
  150   return SearchPlayer::search<AlphaBeta3>(gs, msec);
 
  155                                    Move move, 
int pawn_sacrifice)
 
  157   setUpTable(gs, pawnValueOfTurn<AlphaBeta3>(gs.
state().turn()));
 
  158   AlphaBeta3 searcher(gs.
state(), *checkmate_ptr, table_ptr.get(),
 
  160   return SearchPlayer::isReasonableMoveBySearch(searcher, move, pawn_sacrifice);
 
  178   return cloneIt(*
this);
 
  184   const MilliSeconds::Interval consumed = setUpTable(gs, pawnValueOfTurn<AlphaBeta4>(gs.
state().turn()));
 
  189     searcher.reset(
new AlphaBeta4(gs.
state(), *checkmate_ptr, table_ptr.get(),
 
  192   catch (std::bad_alloc&)
 
  194     std::cerr << 
"panic. allocation of AlphaBeta4 failed\n";
 
  196   return SearchPlayer::search<AlphaBeta4>(gs, msec);
 
  201                                    Move move, 
int pawn_sacrifice)
 
  203   setUpTable(gs, pawnValueOfTurn<AlphaBeta4>(gs.
state().turn()));
 
  204   AlphaBeta4 searcher(gs.
state(), *checkmate_ptr, table_ptr.get(),
 
  206   return SearchPlayer::isReasonableMoveBySearch(searcher, move, pawn_sacrifice);