19 #include <boost/foreach.hpp> 
   20 #include <boost/thread/mutex.hpp> 
   26   const CArray<int, PTYPE_SIZE> values = {{
 
   28       583, 493, 491, 467, 1279, 1351,
 
   30       128, 318, 361, 540, 959, 1059
 
   38   static const CArray<const char *,PROGRESS_INDEPENDENT_FEATURE_LIMIT> table = {{
 
   40       "BISHOP_EXCHANGE_SILVER_KING",
 
   42       "KING25_EFFECT_ATTACK",
 
   51   static const CArray<const char *,STAGE_FEATURE_LIMIT> table = {{
 
   52           "KING_PIECE_RELATIVE",
 
   62           "PIECE_STAND_COMBINATION",
 
   70           "PROMOTED_MINOR_PIECE",
 
   71           "KING_PIECE_RELATIVE_NOSUPPORT",
 
   73           "NON_PAWN_ATTACKED_PTYPE",
 
   78           "ROOK_PROMOTE_DEFENSE",
 
   85           "BISHOP_SILVER_KNIGHT",
 
   86           "KING25_EFFECT_SUPPORTED",
 
   93           "KING25_EFFECT_DEFENSE",
 
   96           "NON_PAWN_PIECE_STAND",
 
   99           "GOLD_AND_SILVER_NEAR_KING",
 
  103           "BISHOP_STAND_FILE5",
 
  104           "MAJOR_CHECK_WITH_CAPTURE",
 
  107           "BISHOP_BISHOP_PIECE",
 
  110           "KING25_EFFECT_COUNT_COMBINATION",
 
  111           "NON_PAWN_ATTACKED_PTYPE_PAIR",
 
  112           "ATTACK_MAJORS_IN_BASE",
 
  126   template <
class Eval>
 
  127   static void setRandomOne()
 
  130     for (
size_t i = 0; i < weights.
dimension(); ++i)
 
  134     Eval::setUp(weights);
 
  136   template <
class Eval>
 
  137   static void setRandomOne(
int stage)
 
  140     for (
size_t i = 0; i < weights.
dimension(); ++i)
 
  144     Eval::setUp(weights, stage);
 
  147   template <
class Eval, 
class Reader>
 
  148   static int setUpOneWithDim(Reader& p, 
int dim)
 
  152     for (
size_t i = 0; i < weights.
dimension(); ++i)
 
  159     Eval::setUp(weights);
 
  162   template <
class Eval, 
class Reader>
 
  163   static int setUpOne(Reader& p)
 
  165     return setUpOneWithDim<Eval>(p, Eval::DIM);
 
  167   template <
class Eval, 
class Reader>
 
  168   static int setUpOne(Reader& p, 
int stage)
 
  172     for (
size_t i = 0; i < weights.
dimension(); ++i)
 
  179     Eval::setUp(weights,stage);
 
  195     int read() { 
return array[cur++]; }
 
  203   doResetWeights(reader);
 
  209   if (initialized_flag == Loaded)
 
  212   std::ifstream is(filename, std::ios_base::binary);
 
  214   if (! reader.hasNext()) {
 
  215     initialized_flag = Zero;
 
  216     std::cerr << 
"file " << filename << std::endl;
 
  219   doResetWeights(reader);
 
  220   return initialized_flag == Loaded;
 
  223 template <
class Reader>
 
  227   size_t read_count = 0;
 
  230   CArray<int, PTYPE_SIZE> piece_values = {{0}};
 
  234     if (! reader.hasNext())
 
  236     int val = reader.read();
 
  242     piece_values[i] = val;
 
  246   Piece_Value.reset(piece_values);
 
  250   for (
size_t i = 0; i < piece_pair_weights.dimension(); ++i)
 
  252     if (! reader.hasNext())
 
  254     int val = reader.read();
 
  255     piece_pair_weights.setValue(i, val);
 
  261   read_count += setUpOne<King25EffectAttack>(reader);
 
  262   read_count += setUpOne<King25EffectYAttack>(reader);
 
  263   read_count += setUpOne<PiecePairKing>(reader);
 
  264   read_count += setUpOne<BishopExchangeSilverKing>(reader);
 
  265   read_count += setUpOne<EnterKingDefense>(reader);
 
  268   read_count += setUpOne<PieceStand>(reader,0);
 
  269   read_count += setUpOne<King25EffectEachBothOpening>(reader);
 
  270   read_count += setUpOne<PawnDrop>(reader,0);
 
  271   read_count += setUpOne<NoPawnOnStand>(reader,0);
 
  272   read_count += setUpOne<GoldRetreat>(reader,0);
 
  273   read_count += setUpOne<SilverRetreat>(reader,0);
 
  274   read_count += setUpOne<KnightAdvance>(reader,0);
 
  275   read_count += setUpOne<AllMajor>(reader,0);
 
  276   read_count += setUpOne<KingXBlocked>(reader,0);
 
  277   read_count += setUpOne<KingXBlockedY>(reader,0);
 
  278   read_count += setUpOne<AllGold>(reader,0);
 
  279   read_count += setUpOne<PtypeX>(reader,0);
 
  280   read_count += setUpOne<PtypeY>(reader,0);
 
  281   read_count += setUpOne<AnagumaEmpty>(reader,0);
 
  282   read_count += setUpOne<NonPawnPieceStand>(reader,0);
 
  283   read_count += setUpOne<King25EffectDefense>(reader,0);
 
  284   read_count += setUpOne<King25EffectYDefense>(reader,0);
 
  285   read_count += setUpOne<RookMobility>(reader,0);
 
  286   read_count += setUpOne<BishopMobility>(reader,0);
 
  287   read_count += setUpOne<LanceMobility>(reader,0);
 
  288   read_count += setUpOne<RookEffect>(reader,0);
 
  289   read_count += setUpOne<BishopEffect>(reader,0);
 
  290   read_count += setUpOne<PawnAdvance>(reader,0);
 
  291   read_count += setUpOne<PawnDropY>(reader,0);
 
  292   read_count += setUpOne<KnightCheck>(reader,0);
 
  295   read_count += setUpOne<PieceStand>(reader,1);
 
  296   read_count += setUpOne<King25EffectEachBothMidgame>(reader);
 
  297   read_count += setUpOne<PawnDrop>(reader,1);
 
  298   read_count += setUpOne<NoPawnOnStand>(reader,1);
 
  299   read_count += setUpOne<GoldRetreat>(reader,1);
 
  300   read_count += setUpOne<SilverRetreat>(reader,1);
 
  301   read_count += setUpOne<KnightAdvance>(reader,1);
 
  302   read_count += setUpOne<AllMajor>(reader,1);
 
  303   read_count += setUpOne<KingXBlocked>(reader,1);
 
  304   read_count += setUpOne<KingXBlockedY>(reader,1);
 
  305   read_count += setUpOne<AllGold>(reader,1);
 
  306   read_count += setUpOne<PtypeX>(reader,1);
 
  307   read_count += setUpOne<PtypeY>(reader,1);
 
  308   read_count += setUpOne<AnagumaEmpty>(reader,1);
 
  309   read_count += setUpOne<NonPawnPieceStand>(reader,1);
 
  310   read_count += setUpOne<King25EffectDefense>(reader,1);
 
  311   read_count += setUpOne<King25EffectYDefense>(reader,1);
 
  312   read_count += setUpOne<RookMobility>(reader,1);
 
  313   read_count += setUpOne<BishopMobility>(reader,1);
 
  314   read_count += setUpOne<LanceMobility>(reader,1);
 
  315   read_count += setUpOne<RookEffect>(reader,1);
 
  316   read_count += setUpOne<BishopEffect>(reader,1);
 
  317   read_count += setUpOne<PawnAdvance>(reader,1);
 
  318   read_count += setUpOne<PawnDropY>(reader,1);
 
  319   read_count += setUpOne<KnightCheck>(reader,1);
 
  323   read_count += setUpOne<PieceStand>(reader,2);
 
  324   read_count += setUpOne<King25EffectEachBothMidgame2>(reader);
 
  325   read_count += setUpOne<PawnDrop>(reader,2);
 
  326   read_count += setUpOne<NoPawnOnStand>(reader,2);
 
  327   read_count += setUpOne<GoldRetreat>(reader,2);
 
  328   read_count += setUpOne<SilverRetreat>(reader,2);
 
  329   read_count += setUpOne<KnightAdvance>(reader,2);
 
  330   read_count += setUpOne<AllMajor>(reader,2);
 
  331   read_count += setUpOne<KingXBlocked>(reader,2);
 
  332   read_count += setUpOne<KingXBlockedY>(reader,2);
 
  333   read_count += setUpOne<AllGold>(reader,2);
 
  334   read_count += setUpOne<PtypeX>(reader,2);
 
  335   read_count += setUpOne<PtypeY>(reader,2);
 
  336   read_count += setUpOne<AnagumaEmpty>(reader,2);
 
  337   read_count += setUpOne<NonPawnPieceStand>(reader,2);
 
  338   read_count += setUpOne<King25EffectDefense>(reader,2);
 
  339   read_count += setUpOne<King25EffectYDefense>(reader,2);
 
  340   read_count += setUpOne<RookMobility>(reader,2);
 
  341   read_count += setUpOne<BishopMobility>(reader,2);
 
  342   read_count += setUpOne<LanceMobility>(reader,2);
 
  343   read_count += setUpOne<RookEffect>(reader,2);
 
  344   read_count += setUpOne<BishopEffect>(reader,2);
 
  345   read_count += setUpOne<PawnAdvance>(reader,2);
 
  346   read_count += setUpOne<PawnDropY>(reader,2);
 
  347   read_count += setUpOne<KnightCheck>(reader,2);
 
  351   read_count += setUpOne<PieceStand>(reader,
EndgameIndex);
 
  352   read_count += setUpOne<King25EffectEachBothEnding>(reader);
 
  354   read_count += setUpOne<NoPawnOnStand>(reader,
EndgameIndex);
 
  355   read_count += setUpOne<GoldRetreat>(reader,
EndgameIndex);
 
  356   read_count += setUpOne<SilverRetreat>(reader,
EndgameIndex);
 
  357   read_count += setUpOne<KnightAdvance>(reader,
EndgameIndex);
 
  359   read_count += setUpOne<KingXBlocked>(reader,
EndgameIndex);
 
  360   read_count += setUpOne<KingXBlockedY>(reader,
EndgameIndex);
 
  364   read_count += setUpOne<AnagumaEmpty>(reader,
EndgameIndex);
 
  365   read_count += setUpOne<NonPawnPieceStand>(reader,
EndgameIndex);
 
  366   read_count += setUpOne<King25EffectDefense>(reader,
EndgameIndex);
 
  367   read_count += setUpOne<King25EffectYDefense>(reader,
EndgameIndex);
 
  368   read_count += setUpOne<RookMobility>(reader,
EndgameIndex);
 
  369   read_count += setUpOne<BishopMobility>(reader,
EndgameIndex);
 
  370   read_count += setUpOne<LanceMobility>(reader,
EndgameIndex);
 
  371   read_count += setUpOne<RookEffect>(reader,
EndgameIndex);
 
  372   read_count += setUpOne<BishopEffect>(reader,
EndgameIndex);
 
  373   read_count += setUpOne<PawnAdvance>(reader,
EndgameIndex);
 
  375   read_count += setUpOne<KnightCheck>(reader,
EndgameIndex);
 
  378   read_count += setUpOne<KingPieceRelative>(reader,0);
 
  379   read_count += setUpOne<KingPieceRelative>(reader,1);
 
  381   read_count += setUpOne<KingPieceRelative>(reader,2);
 
  383   read_count += setUpOne<KingPieceRelative>(reader,
EndgameIndex);
 
  384   read_count += setUpOne<NonPawnPieceStandTurn>(reader);
 
  385   read_count += setUpOne<King25EffectEachXY>(reader);
 
  386   read_count += setUpOne<RookPawnY>(reader);
 
  387   read_count += setUpOne<RookEffectPiece>(reader);
 
  388   read_count += setUpOne<BishopEffectPiece>(reader);
 
  389   read_count += setUpOne<PieceStandY>(reader);
 
  390   read_count += setUpOne<RookEffectPieceKingRelative>(reader);
 
  391   read_count += setUpOne<BishopEffectPieceKingRelative>(reader);
 
  392   read_count += setUpOne<RookPawnYX>(reader);
 
  393   read_count += setUpOne<PawnPtypeOPtypeO>(reader);
 
  394   read_count += setUpOne<PromotedMinorPieces>(reader);
 
  395   read_count += setUpOne<KingPieceRelativeNoSupport>(reader);
 
  396   read_count += setUpOne<NonPawnAttacked>(reader);
 
  397   read_count += setUpOne<PtypeYY>(reader);
 
  398   read_count += setUpOne<PawnPtypeOPtypeOY>(reader);
 
  399   read_count += setUpOne<PawnDropX>(reader);
 
  400   read_count += setUpOne<King3Pieces>(reader);
 
  401   read_count += setUpOne<King3PiecesXY>(reader);
 
  402   read_count += setUpOne<King25EffectEachKXY>(reader);
 
  403   read_count += setUpOne<BishopHead>(reader);
 
  404   read_count += setUpOne<BishopHeadKingRelative>(reader);
 
  405   read_count += setUpOne<KnightCheckY>(reader);
 
  406   read_count += setUpOne<KnightHead>(reader);
 
  407   read_count += setUpOne<RookPromoteDefense>(reader);
 
  408   read_count += setUpOne<PawnDropPawnStand>(reader);
 
  409   read_count += setUpOne<PawnDropPawnStandX>(reader);
 
  410   read_count += setUpOne<PawnDropPawnStandY>(reader);
 
  411   read_count += setUpOne<KnightHeadOppPiecePawnOnStand>(reader);
 
  412   read_count += setUpOne<KingXBothBlocked>(reader);
 
  413   read_count += setUpOne<KingXBothBlockedY>(reader);
 
  414   read_count += setUpOne<KingRookBishop>(reader);
 
  415   read_count += setUpOne<PromotedMinorPiecesY>(reader);
 
  416   read_count += setUpOne<King25EffectSupported>(reader);
 
  417   read_count += setUpOne<King25EffectSupportedY>(reader);
 
  418   read_count += setUpOne<NonPawnAttackedKingRelative>(reader);
 
  419   read_count += setUpOne<NonPawnAttackedPtype>(reader);
 
  420   read_count += setUpOne<PtypeCount>(reader);
 
  421   read_count += setUpOne<KingXBlocked3>(reader);
 
  422   read_count += setUpOne<KingXBlocked3Y>(reader);
 
  423   read_count += setUpOne<PtypeCountXY>(reader);
 
  424   read_count += setUpOne<PtypeCountXYAttack>(reader);
 
  425   read_count += setUpOne<LanceEffectPieceKingRelative>(reader);
 
  426   read_count += setUpOne<KingMobility>(reader);
 
  427   read_count += setUpOne<KingMobilitySum>(reader);
 
  428   read_count += setUpOne<PtypeYPawnY>(reader);
 
  429   read_count += setUpOne<GoldAndSilverNearKing>(reader);
 
  430   read_count += setUpOne<PtypeCombination>(reader);
 
  431   read_count += setUpOne<PieceStandCombinationBoth>(reader);
 
  432   read_count += setUpOne<King25BothSide>(reader);
 
  433   read_count += setUpOne<King25BothSideX>(reader);
 
  434   read_count += setUpOne<King25BothSideY>(reader);
 
  435   read_count += setUpOne<GoldAndSilverNearKingCombination>(reader);
 
  436   read_count += setUpOne<KingMobilityWithRook>(reader);
 
  437   read_count += setUpOne<KingMobilityWithBishop>(reader);
 
  438   read_count += setUpOne<NumPiecesBetweenBishopAndKingSelf>(reader);
 
  439   read_count += setUpOne<NumPiecesBetweenBishopAndKingOpp>(reader);
 
  440   read_count += setUpOne<NumPiecesBetweenBishopAndKingAll>(reader);
 
  441   read_count += setUpOne<King25Effect3>(reader);
 
  442   read_count += setUpOne<SilverHeadPawnKingRelative>(reader);
 
  443   read_count += setUpOne<GoldKnightKingRelative>(reader);
 
  444   read_count += setUpOne<RookMobilitySum>(reader);
 
  445   read_count += setUpOne<RookMobilityX>(reader);
 
  446   read_count += setUpOne<RookMobilityY>(reader);
 
  447   read_count += setUpOne<RookMobilitySumKingX>(reader);
 
  448   read_count += setUpOne<RookMobilityXKingX>(reader);
 
  449   read_count += setUpOne<PinPtype>(reader);
 
  450   read_count += setUpOne<PinPtypeDistance>(reader);
 
  451   read_count += setUpOne<BishopMobilityEach>(reader);
 
  452   read_count += setUpOne<BishopBishopPiece>(reader);
 
  453   read_count += setUpOne<NonPawnPieceStandCombination>(reader);
 
  454   read_count += setUpOne<CanCheckNonPawnPieceStandCombination>(reader);
 
  455   read_count += setUpOne<King25Effect3Y>(reader);
 
  456   read_count += setUpOne<RookRook>(reader);
 
  457   read_count += setUpOne<RookRookPiece>(reader);
 
  458   read_count += setUpOne<PinPtypePawnAttack>(reader);
 
  459   read_count += setUpOne<King25Mobility>(reader);
 
  460   read_count += setUpOne<King25MobilityX>(reader);
 
  461   read_count += setUpOne<King25MobilityY>(reader);
 
  462   read_count += setUpOne<King25EffectCountCombination>(reader);
 
  463   read_count += setUpOne<GoldSideMove>(reader);
 
  464   read_count += setUpOne<King25EffectCountCombinationY>(reader);
 
  465   read_count += setUpOne<RookPromoteDefenseRookH>(reader);
 
  466   read_count += setUpOne<BishopHeadX>(reader);
 
  467   read_count += setUpOne<PawnDropNonDrop>(reader);
 
  468   read_count += setUpOne<PawnStateKingRelative>(reader);
 
  469   read_count += setUpOne<SilverFork>(reader);
 
  470   read_count += setUpOne<BishopRookFork>(reader);
 
  471   read_count += setUpOne<BishopStandFile5>(reader);
 
  472   read_count += setUpOne<KnightFork>(reader);
 
  473   read_count += setUpOne<NonPawnAttackedPtypePair>(reader);
 
  474   read_count += setUpOne<MajorCheckWithCapture>(reader);
 
  475   read_count += setUpOne<SilverAdvance26>(reader);
 
  476   read_count += setUpOne<RookSilverKnight>(reader);
 
  477   read_count += setUpOne<BishopSilverKnight>(reader);
 
  478   read_count += setUpOne<AttackMajorsInBase>(reader);
 
  479   read_count += setUpOne<CheckShadowPtype>(reader);
 
  480   read_count += setUpOne<Promotion37>(reader);
 
  482   initialized_flag = reader.failed() ? Zero : Loaded;
 
  483   if (initialized_flag != Loaded)
 
  485     std::cerr << 
"Failed to load OpenMidEndingEval data " 
  486               << 
' ' << read_count << std::endl;
 
  493   filename += 
"/data/eval.bin";
 
  499   return setUp(defaultFilename().c_str());  
 
  504   : progress(state), use_progress_independent_value_limit(use_limit)
 
  512        i < PtypeTraits<PAWN>::indexLimit; ++i)
 
  514     const Piece pawn = state.pieceOf(i);
 
  524        i < PtypeTraits<ROOK>::indexLimit; ++i)
 
  526     if (state.pieceOf(i).owner() == 
BLACK)
 
  530        i < PtypeTraits<BISHOP>::indexLimit; ++i)
 
  532     if (state.pieceOf(i).owner() == 
BLACK)
 
  536        i < PtypeTraits<GOLD>::indexLimit; ++i)
 
  538     if (state.pieceOf(i).owner() == 
BLACK)
 
  548     const Piece piece = state.pieceOf(i);
 
  580   King25EffectBoth::countEffectAndPiecesBoth<BLACK>(state, 
effect25[
WHITE],
 
  587   King25EffectBoth::countEffectAndPiecesBoth<WHITE>(state, effect25[
BLACK],
 
  588                                                     effect25_supported[
BLACK],
 
  600                              white_attack_effect, white_attack_piece);
 
  601   recalculated_value +=
 
  605                               white_attack_effect, white_attack_piece);
 
  611                                   black_attack_supported_piece,
 
  612                                   white_attack_supported_piece);
 
  616                                    black_attack_supported_piece,
 
  617                                    white_attack_supported_piece,
 
  618                                    state.kingSquare<
BLACK>().y(),
 
  619                                    state.kingSquare<
WHITE>().y());
 
  624     recalculated_stage_value+=king_rook_bishop[
BLACK]-king_rook_bishop[
WHITE];
 
  637                               white_defense_effect, white_defense_piece);
 
  640                                black_defense_effect,
 
  642                                white_defense_effect, white_defense_piece);
 
  673     CanCheckNonPawnPieceStandCombination::canCheck<BLACK>(state);
 
  675     CanCheckNonPawnPieceStandCombination::canCheck<WHITE>(state);
 
  690     state.effectedMask(BLACK);
 
  693     state.effectedMask(WHITE);
 
  696     state.promotedPieces().getMask<
PAWN>();
 
  699     state.promotedPieces().getMask<
PAWN>();
 
  741     value = PieceEval::evalWithUpdate<BLACK>(state, move, progress_independent_value);
 
  743     value = PieceEval::evalWithUpdate<WHITE>(state, move, progress_independent_value);
 
  745 #ifdef USE_TEST_PROGRESS 
  748                  endgameValue() * progress.progress());
 
  750   return roundUp(value * 16 +
 
  751                  openingValue() * (16 - progress.progress16().value()) + 
 
  752                  endgameValue() * progress.progress16().value());
 
  760   assert(new_state.turn() == turn);
 
  767     updateSub<BLACK>(new_state,last_move);
 
  769     updateSub<WHITE>(new_state,last_move);
 
  771 template<osl::Player P>
 
  775   assert(last_move.
player()==P);
 
  779     new_state.kingSquare<P>();
 
  793       ++non_pawn_stand_count[P];
 
  795     if (captured == 
PAWN)
 
  797       pawns[
alt(P)][last_move.
to().
x() - 1] = 0;
 
  815       const int y_diff = std::abs(last_move.
to().
y() - opp_king.y());
 
  816       const int x_diff = std::abs(last_move.
to().
x() - opp_king.x());
 
  817       if (y_diff <= 2 && x_diff <= 3)
 
  819         --gs_near_king_count[
alt(P)][
std::max(x_diff, y_diff) - 1];
 
  825     if (base_ptype == 
GOLD || base_ptype == 
SILVER)
 
  829         const int y_diff = std::abs(last_move.
from().
y() - self_king.y());
 
  830         const int x_diff = std::abs(last_move.
from().
x() - self_king.x());
 
  831         if (y_diff <= 2 && x_diff <= 3)
 
  833           --gs_near_king_count[P][
std::max(x_diff, y_diff) - 1];
 
  837         const int y_diff = std::abs(last_move.
to().
y() - self_king.y());
 
  838         const int x_diff = std::abs(last_move.
to().
x() - self_king.x());
 
  839         if (y_diff <= 2 && x_diff <= 3)
 
  841           ++gs_near_king_count[P][
std::max(x_diff, y_diff) - 1];
 
  845     if (base_ptype == 
KING)
 
  847       updateGoldSilverNearKing(new_state);
 
  852     --non_pawn_stand_count[P];
 
  856     pawns[P][last_move.
from().
x() - 1] = 0;
 
  860     pawns[P][last_move.
to().
x() - 1] = last_move.
to().
y();
 
  862   const Square kb = new_state.kingSquare<
BLACK>(), kw = new_state.kingSquare<
WHITE>();
 
  864     BoardMask mask = new_state.changedEffects();
 
  865     mask.set(last_move.
from());
 
  866     mask.set(last_move.
to());
 
  870         (effect25_supported[
WHITE] & new_state.effectedMask(
BLACK)) !=
 
  871         effect25_supported[
WHITE] ||
 
  872         (~effect25_supported[
WHITE] & effect25[
WHITE] & ~new_state.effectedMask(
BLACK)) !=
 
  873         (~effect25_supported[
WHITE] & effect25[
WHITE])){
 
  874       King25EffectBoth::countEffectAndPiecesBoth<BLACK>(
 
  875         new_state, effect25[
WHITE], effect25_supported[
WHITE],
 
  876         black_attack_effect, black_attack_piece,
 
  877         white_defense_effect, white_defense_piece,
 
  878         black_attack_supported_piece, white_vertical, white_king_vertical);
 
  879       king25_both_side[
WHITE]=King25BothSide::evalOne<WHITE>(new_state,white_vertical);
 
  882         (effect25_supported[
BLACK] & new_state.effectedMask(WHITE)) !=
 
  883         effect25_supported[
BLACK] ||
 
  884         (~effect25_supported[
BLACK] & effect25[
BLACK] & ~new_state.effectedMask(WHITE)) !=
 
  885         (~effect25_supported[
BLACK] & effect25[
BLACK])){
 
  886       King25EffectBoth::countEffectAndPiecesBoth<WHITE>(
 
  887         new_state, effect25[
BLACK], effect25_supported[
BLACK],
 
  888         white_attack_effect, white_attack_piece,
 
  889         black_defense_effect, black_defense_piece,
 
  890         white_attack_supported_piece, black_vertical, black_king_vertical);
 
  891       king25_both_side[
BLACK]=King25BothSide::evalOne<BLACK>(new_state,black_vertical);
 
  894 #ifdef USE_TEST_PROGRESS 
  895   progress.updateSub<P>(new_state, last_move);
 
  897   progress.update(new_state, last_move);
 
  900   progress_independent_value =
 
  901     PieceEval::evalWithUpdate<P>(new_state, last_move, progress_independent_value);
 
  903     PieceStand::evalWithUpdate<P>(new_state, last_move,
 
  905   if (new_state.longEffectChanged<
ROOK>() || last_move.ptype() == 
KING)
 
  910   if (new_state.longEffectChanged<
BISHOP>())
 
  915   else if (last_move.ptype() == 
KING)
 
  919   if (new_state.longEffectChanged<
LANCE>() || last_move.ptype() == 
KING)
 
  925   if (new_state.anyEffectChanged<
KNIGHT>()) {
 
  931   recalculated_stage_value = silver_features+gold_retreat;
 
  944                              white_attack_effect, white_attack_piece);
 
  945   recalculated_value +=
 
  949                               white_attack_effect, white_attack_piece);
 
  951   recalculated_stage_value += 
 
  953                               white_defense_effect, white_defense_piece);
 
  954   recalculated_stage_value += 
 
  956                                black_defense_effect,
 
  958                                white_defense_effect, white_defense_piece);
 
  959   recalculated_stage_value += knight_advance;
 
  961   recalculated_stage_value += kingx_blocked[
BLACK] + kingx_blocked[
WHITE];
 
  974                                   black_attack_supported_piece,
 
  975                                   white_attack_supported_piece);
 
  979                                    black_attack_supported_piece,
 
  980                                    white_attack_supported_piece,
 
  981                                    new_state.kingSquare<BLACK>().y(),
 
  982                                    new_state.kingSquare<WHITE>().y());
 
  983     recalculated_stage_value += result_supported + result_supported_y;
 
  986       king_rook_bishop[
BLACK]=KingRookBishop::evalOne<BLACK>(new_state);
 
  987       king_rook_bishop[
WHITE]=KingRookBishop::evalOne<WHITE>(new_state);
 
  989     else if(last_move.ptype() == 
KING){
 
  990       king_rook_bishop[P]=KingRookBishop::evalOne<P>(new_state);
 
  992     recalculated_stage_value +=king_rook_bishop[
BLACK]-king_rook_bishop[
WHITE];
 
  994     recalculated_stage_value += king25_both_side[
BLACK]-king25_both_side[
WHITE];
 
  997                                                      white_king_vertical);
 
  999   king_table_value = KingPieceRelative::evalWithUpdate<P>
 
 1000     (new_state, last_move, king_table_value);
 
 1004   PiecePairKing::evalWithUpdateBang<P>(new_state, last_move,
 
 1005                                        piece_pair_king_value);
 
 1006   pawn_drop = PawnDropBoth::evalWithUpdate<P>(new_state,
 
 1007                                               last_move, pawn_drop);
 
 1009   ptypex = PtypeX::evalWithUpdate<P>(new_state, last_move, ptypex);
 
 1010   ptypey = PtypeY::evalWithUpdate<P>(new_state, last_move, ptypey);
 
 1011   CArray<bool, 2> can_check_new;
 
 1012   can_check_new[
BLACK] =
 
 1013     CanCheckNonPawnPieceStandCombination::canCheck<BLACK>(new_state);
 
 1014   can_check_new[
WHITE] =
 
 1015     CanCheckNonPawnPieceStandCombination::canCheck<WHITE>(new_state);
 
 1016   piece_stand_combination =
 
 1019                                                  piece_stand_combination,
 
 1022   can_check = can_check_new;
 
 1023   NonPawnPieceStandTurn::evalWithUpdateBang<P>(new_state,
 
 1027   piece_stand_y = PieceStandY::evalWithUpdate<P>(new_state, last_move,
 
 1029   PawnAdvanceAll::evalWithUpdateBang<P>(new_state,
 
 1034   pawn_ptypeo = PawnPtypeOPtypeO::template evalWithUpdate<P>(new_state, last_move,
 
 1038   promoted_minor_piece =
 
 1041                                         promoted_minor_piece);
 
 1046   NonPawnAttacked::evalWithUpdateBang<P>(new_state,
 
 1048                                       effected_mask_for_attacked,
 
 1050   NonPawnAttackedPtype::evalWithUpdateBang<P>(
 
 1051     new_state, last_move, effected_mask_for_attacked,
 
 1052     attacked_mask, non_pawn_attacked_ptype);
 
 1053   effected_mask[
BLACK] =
 
 1054     effected_mask_for_attacked[
BLACK] =
 
 1055     new_state.effectedMask(BLACK);
 
 1056   effected_mask[
WHITE] =
 
 1057     effected_mask_for_attacked[
WHITE] =
 
 1058     new_state.effectedMask(WHITE);
 
 1060     effected_mask_for_attacked[
BLACK].selectBit<
PAWN>() &
 
 1061     new_state.promotedPieces().template getMask<PAWN>();
 
 1063     effected_mask_for_attacked[
WHITE].selectBit<
PAWN>() &
 
 1064     new_state.promotedPieces().template getMask<PAWN>();
 
 1065   effected_mask_for_attacked[
BLACK].clearBit<
PAWN>();
 
 1066   effected_mask_for_attacked[
WHITE].clearBit<
PAWN>();
 
 1075   PtypeCount::evalWithUpdateBang<P>(new_state,
 
 1076                                  last_move, ptype_count, ptype_board_count,
 
 1077                                  ptype_count_value,ptypeo_mask);
 
 1078   PtypeYPawnY::evalWithUpdateBang<P>(new_state, last_move,pawns, ptype_y_pawn_y);
 
 1089   if (base_ptype == 
ROOK || last_move.ptype() == 
SILVER ||
 
 1090       last_move.ptype() == 
KNIGHT ||
 
 1093       (last_move.isPromotion() &&
 
 1098   if (base_ptype == 
BISHOP || last_move.ptype() == 
SILVER ||
 
 1099       last_move.ptype() == 
KNIGHT ||
 
 1102       (last_move.isPromotion() &&
 
 1109 #ifdef USE_TEST_PROGRESS 
 1110   recalculated_stage_value += progress.rawData().promotion37_eval;
 
 1111   recalculated_stage_value += progress.rawData().non_pawn_ptype_attacked_pair_eval[
BLACK]
 
 1112     + progress.rawData().non_pawn_ptype_attacked_pair_eval[
WHITE];
 
 1119   piece_fork_turn += KnightFork::evalWithUpdate<P>(new_state, last_move, knight_fork_squares, knight_drop);
 
 1128   debug_info.
value = value();
 
 1129   debug_info.
progress = progress16().value();
 
 1135   int black_attack_effect, black_attack_piece, black_defense_effect, black_defense_piece,
 
 1136     white_attack_effect, white_attack_piece, white_defense_effect, white_defense_piece;
 
 1137   CArray<int, 5> black_vertical, white_vertical,
 
 1138     black_king_vertical, white_king_vertical;
 
 1139   King25EffectBoth::countEffectAndPiecesBoth<BLACK>(state, effect25[
WHITE],
 
 1140                                                     effect25_supported[
WHITE],
 
 1141                                                     black_attack_effect, black_attack_piece,
 
 1142                                                     white_defense_effect, white_defense_piece,
 
 1143                                                     black_attack_supported_piece,
 
 1145                                                     white_king_vertical);
 
 1146   King25EffectBoth::countEffectAndPiecesBoth<WHITE>(state, effect25[
BLACK],
 
 1147                                                     effect25_supported[
BLACK],
 
 1148                                                     white_attack_effect, white_attack_piece,
 
 1149                                                     black_defense_effect, black_defense_piece,
 
 1150                                                     white_attack_supported_piece,
 
 1152                                                     black_king_vertical);
 
 1155                            black_attack_effect,
 
 1157                            white_attack_effect, white_attack_piece,
 
 1158                            black_defense_effect, black_defense_piece,
 
 1159                            white_defense_effect, white_defense_piece) +
 
 1161                         black_attack_effect,
 
 1163                         white_attack_effect, white_attack_piece,
 
 1164                         black_defense_effect, black_defense_piece,
 
 1165                         white_defense_effect, white_defense_piece);
 
 1174     king25_effect_each[
BLACK] + king25_effect_each[
WHITE];
 
 1209                                 black_attack_supported_piece,
 
 1210                                 white_attack_supported_piece) +
 
 1213                                  black_attack_supported_piece,
 
 1214                                  white_attack_supported_piece,
 
 1215                                  state.kingSquare<
BLACK>().y(),
 
 1216                                  state.kingSquare<
WHITE>().y());
 
 1218     king_rook_bishop[
BLACK] - king_rook_bishop[
WHITE];
 
 1231                               white_defense_effect, white_defense_piece) +
 
 1233                                black_defense_effect,
 
 1234                                black_defense_piece,
 
 1235                                white_defense_effect, white_defense_piece);
 
 1248                                 gs_near_king_count);
 
 1252     king25_both_side[
BLACK] - king25_both_side[
WHITE];
 
 1255                          black_king_vertical,
 
 1256                          white_king_vertical);
 
 1281 #define DEBUGPRINT(x) std::cerr << "  " << #x << " " << x << "\n" 
 1306   DEBUGPRINT(non_pawn_attacked_ptype[turn][0]);
 
 1323   initialized_flag = Random;
 
 1325   setRandomOne<King25EffectAttack>();
 
 1326   setRandomOne<King25EffectYAttack>();
 
 1329   setRandomOne<PieceStand>(0);
 
 1330   setRandomOne<Pin>(0);
 
 1331   setRandomOne<King25EffectEachBothOpening>();
 
 1332   setRandomOne<PawnDrop>(0);
 
 1333   setRandomOne<NoPawnOnStand>(0);
 
 1334   setRandomOne<GoldRetreat>(0);
 
 1335   setRandomOne<SilverRetreat>(0);
 
 1336   setRandomOne<KnightAdvance>(0);
 
 1337   setRandomOne<AllMajor>(0);
 
 1338   setRandomOne<KingXBlocked>(0);
 
 1339   setRandomOne<KingXBlockedY>(0);
 
 1340   setRandomOne<AllGold>(0);
 
 1341   setRandomOne<PtypeX>(0);
 
 1342   setRandomOne<PtypeY>(0);
 
 1343   setRandomOne<AnagumaEmpty>(0);
 
 1344   setRandomOne<NonPawnPieceStand>(0);
 
 1345   setRandomOne<King25EffectDefense>(0);
 
 1346   setRandomOne<King25EffectYDefense>(0);
 
 1347   setRandomOne<RookMobility>(0);
 
 1348   setRandomOne<BishopMobility>(0);
 
 1349   setRandomOne<LanceMobility>(0);
 
 1350   setRandomOne<RookEffect>(0);
 
 1351   setRandomOne<BishopEffect>(0);
 
 1352   setRandomOne<PawnAdvance>(0);
 
 1353   setRandomOne<PawnDropY>(0);
 
 1354   setRandomOne<KnightCheck>(0);
 
 1357   setRandomOne<PieceStand>(1);
 
 1358   setRandomOne<Pin>(1);
 
 1359   setRandomOne<King25EffectEachBothMidgame>();
 
 1360   setRandomOne<PawnDrop>(1);
 
 1361   setRandomOne<NoPawnOnStand>(1);
 
 1362   setRandomOne<GoldRetreat>(1);
 
 1363   setRandomOne<SilverRetreat>(1);
 
 1364   setRandomOne<KnightAdvance>(1);
 
 1365   setRandomOne<AllMajor>(1);
 
 1366   setRandomOne<KingXBlocked>(1);
 
 1367   setRandomOne<KingXBlockedY>(1);
 
 1368   setRandomOne<AllGold>(1);
 
 1369   setRandomOne<PtypeX>(1);
 
 1370   setRandomOne<PtypeY>(1);
 
 1371   setRandomOne<AnagumaEmpty>(1);
 
 1372   setRandomOne<NonPawnPieceStand>(1);
 
 1373   setRandomOne<King25EffectDefense>(1);
 
 1374   setRandomOne<King25EffectYDefense>(1);
 
 1375   setRandomOne<RookMobility>(1);
 
 1376   setRandomOne<BishopMobility>(1);
 
 1377   setRandomOne<LanceMobility>(1);
 
 1378   setRandomOne<RookEffect>(1);
 
 1379   setRandomOne<BishopEffect>(1);
 
 1380   setRandomOne<PawnAdvance>(1);
 
 1381   setRandomOne<PawnDropY>(1);
 
 1382   setRandomOne<KnightCheck>(1);
 
 1386   setRandomOne<PieceStand>(2);
 
 1387   setRandomOne<Pin>(2);
 
 1388   setRandomOne<King25EffectEachBothEnding>();
 
 1389   setRandomOne<PawnDrop>(2);
 
 1390   setRandomOne<NoPawnOnStand>(2);
 
 1391   setRandomOne<GoldRetreat>(2);
 
 1392   setRandomOne<SilverRetreat>(2);
 
 1393   setRandomOne<KnightAdvance>(2);
 
 1394   setRandomOne<AllMajor>(2);
 
 1395   setRandomOne<KingXBlocked>(2);
 
 1396   setRandomOne<KingXBlockedY>(2);
 
 1397   setRandomOne<AllGold>(2);
 
 1398   setRandomOne<PtypeX>(2);
 
 1399   setRandomOne<PtypeY>(2);
 
 1400   setRandomOne<AnagumaEmpty>(2);
 
 1401   setRandomOne<NonPawnPieceStand>(2);
 
 1402   setRandomOne<King25EffectDefense>(2);
 
 1403   setRandomOne<King25EffectYDefense>(2);
 
 1404   setRandomOne<RookMobility>(2);
 
 1405   setRandomOne<BishopMobility>(2);
 
 1406   setRandomOne<LanceMobility>(2);
 
 1407   setRandomOne<RookEffect>(2);
 
 1408   setRandomOne<BishopEffect>(2);
 
 1409   setRandomOne<PawnAdvance>(2);
 
 1410   setRandomOne<PawnDropY>(2);
 
 1411   setRandomOne<KnightCheck>(2);
 
 1416   setRandomOne<King25EffectEachBothMidgame>();
 
 1442   setRandomOne<KingPieceRelative>(0);
 
 1443   setRandomOne<KingPieceRelative>(1);
 
 1445   setRandomOne<KingPieceRelative>(2);
 
 1448   setRandomOne<NonPawnPieceStandCombination>();
 
 1449   setRandomOne<NonPawnPieceStandTurn>();
 
 1450   setRandomOne<King25EffectEachXY>();
 
 1451   setRandomOne<RookPawnY>();
 
 1452   setRandomOne<RookEffectPiece>();
 
 1453   setRandomOne<BishopEffectPiece>();
 
 1454   setRandomOne<PieceStandY>();
 
 1455   setRandomOne<RookEffectPieceKingRelative>();
 
 1456   setRandomOne<BishopEffectPieceKingRelative>();
 
 1457   setRandomOne<RookPawnYX>();
 
 1458   setRandomOne<PawnPtypeOPtypeO>();
 
 1459   setRandomOne<CanCheckNonPawnPieceStandCombination>();
 
 1460   setRandomOne<PromotedMinorPieces>();
 
 1461   setRandomOne<KingPieceRelativeNoSupport>();
 
 1462   setRandomOne<NonPawnAttacked>();
 
 1463   setRandomOne<PtypeYY>();
 
 1464   setRandomOne<PawnPtypeOPtypeOY>();
 
 1465   setRandomOne<PawnDropX>();
 
 1466   setRandomOne<King3Pieces>();
 
 1467   setRandomOne<King3PiecesXY>();
 
 1468   setRandomOne<King25EffectEachKXY>();
 
 1469   setRandomOne<BishopHead>();
 
 1470   setRandomOne<BishopHeadKingRelative>();
 
 1471   setRandomOne<KnightCheckY>();
 
 1472   setRandomOne<KnightHead>();
 
 1473   setRandomOne<RookPromoteDefense>();
 
 1474   setRandomOne<PawnDropPawnStand>();
 
 1475   setRandomOne<PawnDropPawnStandX>();
 
 1476   setRandomOne<PawnDropPawnStandY>();
 
 1477   setRandomOne<King25Effect2>();
 
 1478   setRandomOne<King25EffectY2>();
 
 1479   setRandomOne<KnightHeadOppPiecePawnOnStand>();
 
 1480   setRandomOne<KingXBothBlocked>();
 
 1481   setRandomOne<KingXBothBlockedY>();
 
 1482   setRandomOne<KingRookBishop>();
 
 1483   setRandomOne<PromotedMinorPiecesY>();
 
 1484   setRandomOne<King25EffectSupported>();
 
 1485   setRandomOne<King25EffectSupportedY>();
 
 1486   setRandomOne<NonPawnAttackedKingRelative>();
 
 1487   setRandomOne<NonPawnAttackedPtype>();
 
 1488   setRandomOne<PtypeCount>();
 
 1489   setRandomOne<KingXBlocked3>();
 
 1490   setRandomOne<KingXBlocked3Y>();
 
 1491   setRandomOne<PtypeCountXY>();
 
 1492   setRandomOne<PtypeCountXYAttack>();
 
 1493   setRandomOne<LanceEffectPieceKingRelative>();
 
 1494   setRandomOne<KingMobility>();
 
 1495   setRandomOne<KingMobilitySum>();
 
 1496   setRandomOne<MajorCheckWithCapture>();
 
 1497   setRandomOne<RookSilverKnight>();
 
 1498   setRandomOne<BishopSilverKnight>();
 
 1506   EffectUtil::findThreat<osl::eval::ml::OpenMidEndingEval>(
 
 1507     const NumEffectState& state,