13     for (
int y = 0; y <= 16; ++y)
 
   15       for (
int x = 0; x <= 8; ++x)
 
   17         const int distance = x * 17 + y;
 
   18         attack_table[i][distance][stage] =
 
   20         defense_table[i][distance][stage] =
 
   42       const int attack_index = index(state, 
BLACK,position, w_king);
 
   43       const int defense_index = index(state, 
BLACK,position, b_king);
 
   44       value += attack_table[ptype][attack_index];
 
   45       value += defense_table[ptype][defense_index];
 
   49       const int attack_index = index(state, 
WHITE,position, b_king);
 
   50       const int defense_index = index(state, 
WHITE,position, w_king);
 
   51       value -= attack_table[ptype][attack_index];
 
   52       value -= defense_table[ptype][defense_index];
 
   58 template<osl::Player P>
 
   75     const int attack_index = index(state, ptypeO, moved.
from(), 
false);
 
   76     const int defense_index = index(state,ptypeO, moved.
from(), 
true);
 
   79       value -= attack_table[moved.
oldPtype()][attack_index];
 
   80       value -= defense_table[moved.
oldPtype()][defense_index];
 
   84       value += attack_table[moved.
oldPtype()][attack_index];
 
   85       value += defense_table[moved.
oldPtype()][defense_index];
 
   89     const int attack_index = index(state, moved.
ptypeO(), moved.
to(), 
false);
 
   90     const int defense_index = index(state, moved.
ptypeO(), moved.
to(), 
true);
 
   93       value += attack_table[moved.
ptype()][attack_index];
 
   94       value += defense_table[moved.
ptype()][defense_index];
 
   98       value -= attack_table[moved.
ptype()][attack_index];
 
   99       value -= defense_table[moved.
ptype()][defense_index];
 
  106     const int attack_index = index(state, ptypeO, moved.
to(), 
false);
 
  107     const int defense_index = index(state,ptypeO, moved.
to(), 
true);
 
  110       value += attack_table[
captured][attack_index];
 
  111       value += defense_table[
captured][defense_index];
 
  115       value -= attack_table[
captured][attack_index];
 
  116       value -= defense_table[
captured][defense_index];
 
  129   for (
int i = 0; i < ONE_DIM; ++i)
 
  132       table[i][s] = weights.
value(i + ONE_DIM*s);
 
  136 template <
int Sign> 
inline 
  141     out += table[attack] + table[defense];
 
  143     out -= table[attack] + table[defense];
 
  150   const CArray<Square, 2> kings = {{ 
 
  151       state.kingSquare(
BLACK),
 
  152       state.kingSquare(
WHITE),
 
  154   PieceMask black = (~state.effectedMask(
BLACK)) & state.piecesOnBoard(
BLACK);
 
  158     const Piece piece = state.pieceOf(black.takeOneBit());
 
  159     const int index_attack = index(
BLACK, kings[
WHITE],
 
  161     const int index_defense = index(
BLACK, kings[
BLACK],
 
  162                                     piece) + ONE_DIM / 2;
 
  163     adjust<1>(index_attack, index_defense, 
result);
 
  165   PieceMask white = (~state.effectedMask(
WHITE)) & state.piecesOnBoard(
WHITE);
 
  169     const Piece piece = state.pieceOf(white.takeOneBit());
 
  170     const int index_attack = index(
WHITE, kings[
BLACK],
 
  172     const int index_defense = index(
WHITE, kings[
WHITE],
 
  173                                     piece) + ONE_DIM / 2;
 
  181   const NumEffectState &state,
 
  183   const CArray<PieceMask, 2> &effected_mask,
 
  189   const CArray<PieceMask, 2> new_mask = {{
 
  190       state.effectedMask(
BLACK),
 
  191       state.effectedMask(
WHITE)
 
  193   const CArray<Square, 2> kings = {{ 
 
  194       state.kingSquare<
BLACK>(),
 
  195       state.kingSquare<
WHITE>(),
 
  199   const Piece p = state.pieceAt(moved.
to());
 
  204       const int index_attack =
 
  207       const int index_defense =
 
  209               moved.
from()) + ONE_DIM / 2;
 
  211         adjust<-1>(index_attack, index_defense, result);
 
  213         adjust<1>(index_attack, index_defense, 
result);
 
  219     PieceMask captured_mask =
 
  220       effected_mask[moved.
player()] & (~state.piecesOnBoard(
BLACK)) &
 
  221       (~state.piecesOnBoard(
WHITE));
 
  223     if (!effected_mask[
alt(moved.
player())].test(captured_mask.takeOneBit()))
 
  225       const int index_attack =
 
  228       const int index_defense =
 
  230               moved.
to()) + ONE_DIM / 2;
 
  232         adjust<1>(index_attack, index_defense, result);
 
  239     const int index_attack =
 
  242     const int index_defense =
 
  244             moved.
to()) + ONE_DIM / 2;
 
  246       adjust<1>(index_attack, index_defense, result);
 
  250   PieceMask onboard_black = state.piecesOnBoard(
BLACK);
 
  253   PieceMask black_old = (~effected_mask[0]) & new_mask[0] & onboard_black;
 
  254   black_old.reset(p.
number());
 
  255   while (black_old.any())
 
  257     const Piece piece = state.pieceOf(black_old.takeOneBit());
 
  258     const int index_attack =
 
  260     const int index_defense =
 
  261       index(
BLACK, kings[
BLACK], piece) + ONE_DIM / 2;
 
  265   PieceMask black_new = effected_mask[0] & (~new_mask[0]) & onboard_black;
 
  266   black_new.reset(p.
number());
 
  267   while (black_new.any())
 
  269     const Piece piece = state.pieceOf(black_new.takeOneBit());
 
  270     const int index_attack =
 
  272     const int index_defense =
 
  273       index(
BLACK, kings[
BLACK], piece) + ONE_DIM / 2;
 
  274     adjust<1>(index_attack, index_defense, 
result);
 
  278   PieceMask onboard_white = state.piecesOnBoard(
WHITE);
 
  280   PieceMask white_old = (~effected_mask[1]) & new_mask[1] & onboard_white;
 
  281   white_old.reset(p.
number());
 
  282   while (white_old.any())
 
  284     const Piece piece = state.pieceOf(white_old.takeOneBit());
 
  285     const int index_attack =
 
  287     const int index_defense =
 
  288       index(
WHITE, kings[
WHITE], piece) + ONE_DIM / 2;
 
  289     adjust<1>(index_attack, index_defense, 
result);
 
  292   PieceMask white_new = effected_mask[1] & (~new_mask[1]) & onboard_white;
 
  293   white_new.reset(p.
number());
 
  294   while (white_new.any())
 
  296     const Piece piece = state.pieceOf(white_new.takeOneBit());
 
  297     const int index_attack =
 
  299     const int index_defense =
 
  300       index(
WHITE, kings[
WHITE], piece) + ONE_DIM / 2;
 
  312   for (
int i = 0; i < 
ONE_DIM; ++i)
 
  325     out += table[black] - table[white];
 
  327     out -= table[black] - table[white];
 
  334   const CArray<Square,2> kings = {{ 
 
  335       state.kingSquare(
BLACK),
 
  336       state.kingSquare(
WHITE),
 
  340     const Piece p = state.pieceOf(i);
 
  343     const int black_index = index<BLACK>(p, kings[
BLACK]);
 
  344     const int white_index = index<WHITE>(p, kings[
WHITE]);
 
  345     adjust<1>(black_index, white_index, 
result);
 
  352   const NumEffectState& state,
 
  363     const int index_black = index<BLACK>(moved.
oldPtypeO(), moved.
from(),
 
  364                                          state.kingSquare<
BLACK>());
 
  365     const int index_white = index<WHITE>(moved.
oldPtypeO(), moved.
from(),
 
  366                                          state.kingSquare<
WHITE>());
 
  373     const int index_black = index<BLACK>(ptypeO, moved.
to(),
 
  374                                          state.kingSquare<
BLACK>());
 
  375     const int index_white = index<WHITE>(ptypeO, moved.
to(),
 
  376                                          state.kingSquare<
WHITE>());
 
  381     const int index_black = index<BLACK>(moved.
ptypeO(), moved.
to(),
 
  382                                          state.kingSquare<
BLACK>());
 
  383     const int index_white = index<WHITE>(moved.
ptypeO(), moved.
to(),
 
  384                                          state.kingSquare<
WHITE>());
 
  385     adjust<1>(index_black, index_white, 
result);
 
  398   for (
size_t i = 0; i < weights.
dimension(); ++i)
 
  400     table[i] = weights.
value(i);
 
  411   const int min_x = 
std::max(1, king.
x() - 2);
 
  412   const int max_x = 
std::min(9, king.
x() + 2);
 
  413   const int min_y = 
std::max(1, king.
y() - 2);
 
  414   const int max_y = 
std::min(9, king.
y() + 2);
 
  418   for (
int y = min_y; y <= max_y; ++y)
 
  420     for (
int x = min_x; x <= max_x; ++x)
 
  429   piece = 
std::min(16,  mask.countBit());
 
  434   return effect + 128 * piece_count;
 
  440   int black_effect, black_piece, white_effect, white_piece;
 
  441   countEffectAndPieces(state, 
osl::BLACK, black_effect, black_piece);
 
  442   countEffectAndPieces(state, 
osl::WHITE, white_effect, white_piece);
 
  443   return table[index(black_effect, black_piece)] - table[index(white_effect, white_piece)];
 
  454   for (
int i = 0; i < ONE_DIM; ++i)
 
  457       table[i][s] = weights.
value(i + ONE_DIM*s);
 
  463   for (
int i = 0; i < ONE_DIM; ++i)
 
  466       table[i][s] = weights.
value(i + ONE_DIM*s);
 
  478   for (
int i = 0; i < ONE_DIM; ++i)
 
  481       table[i][s] = weights.
value(i + ONE_DIM*s);
 
  487   for (
int i = 0; i < ONE_DIM; ++i)
 
  490       table[i][s] = weights.
value(i + ONE_DIM*s);
 
  503   attack_table.fill(0);
 
  504   defense_table.fill(0);
 
  505   for (
size_t i = 0; i < DIM/2; ++i)
 
  507     attack_table[i] = weights.
value(i);
 
  508     defense_table[i] = weights.
value(i+DIM/2);
 
  512 template <osl::Player Attack>
 
  517   PieceMask& supported_mask,
 
  522   int &attack_piece_supported,
 
  523   CArray<int, 5> &verticals,
 
  524   CArray<int, 5> &king_verticals)
 
  526   king_verticals.fill(0);
 
  529   const int min_x = 
std::max(1, king.
x() - 2);
 
  530   const int max_x = 
std::min(9, king.
x() + 2);
 
  531   const int min_y = 
std::max(1, king.
y() - 2);
 
  532   const int max_y = 
std::min(9, king.
y() + 2);
 
  533   int mask_all=(1<<5)-1;
 
  534   verticals.fill(mask_all);
 
  535   const int y_mask_base=(1 << (Defense == 
BLACK ? (min_y-king.
y()) + 2 : -(max_y-king.
y()) + 2));
 
  537     mask_all ^= ((1<<(max_y-king.
y()+3))-y_mask_base);
 
  539     mask_all ^= ((1<<(king.
y()-min_y+3))-y_mask_base);
 
  541   int attack_count = 0;
 
  542   int defense_count = 0;
 
  543   for (
int x = min_x; x <= max_x; ++x)
 
  545     int vertical_x=mask_all;
 
  546     int king_vertical_x = 0;
 
  548       int y_mask=y_mask_base;
 
  549       for (
int y = min_y; y <= max_y; ++y, y_mask+=y_mask)
 
  556           attack_count += 
count;
 
  557           vertical_x |= y_mask;
 
  563           king_vertical_x |= y_mask;
 
  568       int y_mask=y_mask_base;
 
  569       for (
int y = max_y; y >= min_y; --y, y_mask+=y_mask)
 
  576           attack_count += 
count;
 
  577           vertical_x |= y_mask;
 
  583           king_vertical_x |= y_mask;
 
  587     const int x_diff = king.
x() - x;
 
  588     verticals[(Defense == 
BLACK ? 2 - x_diff : 2 + x_diff)] = vertical_x;
 
  589     king_verticals[(Defense == 
BLACK ? 2 - x_diff : 2 + x_diff)] =
 
  592   attack_effect = 
std::min(127, attack_count);
 
  593   defense_effect = 
std::min(127, defense_count);
 
  595   attack_piece = 
std::min(16,  attack_mask.countBit());
 
  597   defense_piece = 
std::min(16,  defense_mask.countBit());
 
  598   supported_mask = attack_mask & state.
effectedMask(Attack);
 
  599   attack_piece_supported = 
std::min(16, supported_mask.countBit());
 
  611   attack_table.fill(0);
 
  612   defense_table.fill(0);
 
  613   for (
size_t i = 0; i < DIM/2; ++i)
 
  615     attack_table[i] = weights.
value(i);
 
  616     defense_table[i] = weights.
value(i+DIM/2);
 
  626   for (
size_t i = 0; i < weights.
dimension(); ++i)
 
  628     table[i] = weights.
value(i);
 
  632 template <osl::Player defense>
 
  637   const Piece king_piece = state.kingPiece<defense>();
 
  639   const int min_x = 
std::max(1, king.x() - 2);
 
  640   const int max_x = 
std::min(9, king.x() + 2);
 
  641   const int min_y = 
std::max(1, king.y() - 2);
 
  642   const int max_y = 
std::min(9, king.y() + 2);
 
  644   PieceMask pieces=state.piecesOnBoard(defense);
 
  647   for (
int x = min_x; x <= max_x; ++x)
 
  649     for (
int y = min_y; y <= max_y; ++y)
 
  652       if (state.pieceAt(target).isEmpty()
 
  654           (pieces & state.effectSetAt(target)).any())
 
  656         if (defense == 
BLACK)
 
  657           result += table[index(x - king.x(), y - king.y())];
 
  659           result -= table[index(king.x() - x, king.y() - y)];
 
  666 template <osl::Player defense>
 
  669                                      const CArray<int, 15>& opening, 
const CArray<int, 15>& ending)
 
  671   int result_o = 0, result_e = 0;
 
  672   const Piece king_piece = state.kingPiece<defense>();
 
  674   const int min_x = 
std::max(1, king.x() - 2);
 
  675   const int max_x = 
std::min(9, king.x() + 2);
 
  676   const int min_y = 
std::max(1, king.y() - 2);
 
  677   const int max_y = 
std::min(9, king.y() + 2);
 
  679   PieceMask pieces=state.piecesOnBoard(defense);
 
  682   for (
int x = min_x; x <= max_x; ++x)
 
  684     for (
int y = min_y; y <= max_y; ++y)
 
  687       if (state.pieceAt(target).isEmpty()
 
  689           (pieces & state.effectSetAt(target)).any())
 
  691         if (defense == 
BLACK) 
 
  693           result_o += opening[index(x - king.x(), y - king.y())];
 
  694           result_e += ending[index(x - king.x(), y - king.y())];
 
  698           result_o -= opening[index(king.x() - x, king.y() - y)];
 
  699           result_e -= ending[index(king.x() - x, king.y() - y)];
 
  704   return std::make_pair(result_o, result_e);
 
  709                                   const CArray<int, 15>& opening, 
const CArray<int, 15>& ending)
 
  711   std::pair<int,int> b = evalOne<BLACK>(state, opening, ending);
 
  712   std::pair<int,int> w = evalOne<WHITE>(state, opening, ending);
 
  713   CArray<int,2> result_o = {{ b.first, w.first }};
 
  714   CArray<int,2> result_e = {{ b.second, w.second }};
 
  715   return std::make_pair(result_o, result_e);
 
  720                                             const CArray<int, 15>& opening, 
const CArray<int, 15>& ending,
 
  721                                             const CArray<int, 2>& last_opening_value, 
 
  722                                             const CArray<int, 2>& last_ending_value)
 
  724   BoardMask mb = state.changedEffects(
BLACK), mw = state.changedEffects(
WHITE);
 
  727   const Square kb = state.kingSquare<
BLACK>(), kw = state.kingSquare<
WHITE>();
 
  730   std::pair<int,int> b = update_black 
 
  731     ? evalOne<BLACK>(state, opening, ending)
 
  732     : std::make_pair(last_opening_value[0], last_ending_value[0]);
 
  733   std::pair<int,int> w = update_white
 
  734     ? evalOne<WHITE>(state, opening, ending)
 
  735     : std::make_pair(last_opening_value[1], last_ending_value[1]);
 
  736   CArray<int,2> result_o = {{ b.first, w.first }};
 
  737   CArray<int,2> result_e = {{ b.second, w.second }};
 
  738   return std::make_pair(result_o, result_e);
 
  750   CArray<int, 2> 
result = {{ evalOne<BLACK>(state, table), evalOne<WHITE>(state, table) }};
 
  757   CArray<int, 2> 
result = {{ evalOne<BLACK>(state, table), evalOne<WHITE>(state, table) }};
 
  771   for (
size_t i = 0; i < weights.
dimension(); ++i)
 
  773     table[i] = weights.
value(i);
 
  778 template <osl::Player Defense>
 
  781   const NumEffectState &state,
 
  784   if (!state.hasEffectAt(
alt(Defense), target))
 
  788   const int diff = state.countEffect(Defense, target) -
 
  789     state.countEffect(
alt(Defense), target);
 
  794 template <osl::Player Defense>
 
  796   const NumEffectState &state, 
Square king,
 
  799   const Piece piece = state.pieceAt(target);
 
  801   const int rel_x = std::abs(king.
x() - target.
x());
 
  803   const int rel_y = (target.
y() - king.
y()) * (Defense == 
BLACK ? 1 : -1);
 
  807   else if (piece.
owner() == Defense)
 
  812   int val = rel_y + 2 + rel_x * 5 +
 
  813     effectState<Defense>(state, 
target) * 5 * 3 +
 
  814     piece_owner * 5 * 3 * 8;
 
  819 template <osl::Player Defense>
 
  821   const NumEffectState &state)
 
  824   const Square king = state.kingSquare<Defense>();
 
  825   const int min_x = 
std::max(1, king.
x() - 2);
 
  826   const int max_x = 
std::min(9, king.
x() + 2);
 
  827   const int min_y = 
std::max(1, king.
y() - 2);
 
  828   const int max_y = 
std::min(9, king.
y() + 2);
 
  829   for (
int x = min_x; x <= max_x; ++x)
 
  831     for (
int y = min_y; y <= max_y; ++y)
 
  834       result += table[index<Defense>(state, king, 
target)];
 
  837   if (Defense == 
BLACK)
 
  847   return evalOne<BLACK>(state) + evalOne<WHITE>(state);
 
  864   for (
size_t i = 0; i < weights.
dimension(); ++i)
 
  873   for (
size_t i = 0; i < weights.
dimension(); ++i)
 
  882   for (
size_t i = 0; i < weights.
dimension(); ++i)
 
  891   for (
size_t i = 0; i < weights.
dimension(); ++i)
 
  899   for(
int rel_y_2=0;rel_y_2<5;rel_y_2++)
 
  900     for(
int x_diff_2=0;x_diff_2<5;x_diff_2++)
 
  901       for(
int es=0;es<8;es++)
 
  902         for(
int po=0;po<3;po++)
 
  903           for(
int king_x_1=0;king_x_1<5;king_x_1++){
 
  904             int oldIndex=(rel_y_2+x_diff_2*5+es*5*5+po*5*5*8)*5+king_x_1;
 
  905             int newIndex=po+3*(es+8*(rel_y_2+5*(x_diff_2+5*king_x_1)));
 
  909   for(
int rel_y_2=0;rel_y_2<5;rel_y_2++)
 
  910     for(
int rel_x=0;rel_x<3;rel_x++)
 
  911       for(
int es=0;es<8;es++)
 
  912         for(
int po=0;po<3;po++)
 
  913           for(
int king_y_1=0;king_y_1<9;king_y_1++){
 
  914             int oldIndex=(rel_y_2+rel_x*5+es*5*3+po*5*3*8)*9+king_y_1;
 
  915             int newIndex=po+3*(es+8*(rel_y_2+5*(rel_x+3*king_y_1)));
 
  919   for(
int d_effect=0;d_effect<16;d_effect++){
 
  920     for(
int a_effect=0;a_effect<16;a_effect++){
 
  925         int diff=d_effect-a_effect;
 
  936   for(
int rel_y_2=0;rel_y_2<5;rel_y_2++)
 
  937     for(
int x_diff_2=0;x_diff_2<5;x_diff_2++){
 
  938       int rel_x=std::abs(x_diff_2-2);
 
  939       for(
int es=0;es<8;es++)
 
  940         for(
int po=0;po<3;po++)
 
  941           for(
int king_x_1=0;king_x_1<5;king_x_1++)
 
  942             for (
int king_y_1=0;king_y_1<9;king_y_1++) {
 
  943               int oldIndex=((rel_y_2+x_diff_2*5+es*5*5+po*5*5*8)*9+king_y_1)*5 + king_x_1;
 
  944               int newIndexX=po+3*(es+8*(rel_y_2+5*(x_diff_2+5*king_x_1)));
 
  945               int newIndexY=po+3*(es+8*(rel_y_2+5*(rel_x+3*king_y_1)));
 
  946               int newIndex=po+3*(es+8*(rel_y_2+5*(x_diff_2+5*(king_x_1+5*king_y_1))));
 
  953 template <osl::Player Defense>
 
  958   NumBitmapEffect effect=state.effectSetAt(target);
 
  959   const int d_effect=effect.countEffect(Defense);
 
  961   return effect_state_table[a_effect*16+d_effect];
 
  964 template <osl::Player Defense>
 
  966   const NumEffectState &state, 
 
  968   int rel_y, 
int king_x, 
int king_y, 
int x_diff)
 
  970   const Piece piece = state.pieceAt(target);
 
  975 #ifdef __INTEL_COMPILER 
  976     piece_owner = (
unsigned int)((
int)(ptypeO)>>30);
 
  978     piece_owner |= (ptypeO+14)>>4;
 
  980     piece_owner=((ptypeO+14)>>4)|(((
unsigned int)ptypeO>>30)&0x2);
 
  984     piece_owner=(((ptypeO+14)>>3)&0x2)|((
unsigned int)ptypeO>>31);
 
  986   assert(piece_owner >= 0 && piece_owner < 3);
 
  987   int effect_state_index = effectStateIndex3<Defense>(state, 
target);
 
  989   index_xy=piece_owner+effect_state_index+3*(8*((rel_y+2)+5*((x_diff+2)+5*(king_x-1+5*(king_y-1)))));
 
  992 template <osl::Player Defense>
 
  997   const Square king = state.kingSquare<Defense>();
 
  998   const int min_dx = 
std::max(1, king.
x() - 2)-king.
x();
 
  999   const int max_dx = 
std::min(9, king.
x() + 2)-king.
x();
 
 1000   const int min_dy = 
std::max(1, king.
y() - 2)-king.
y();
 
 1001   const int max_dy = 
std::min(9, king.
y() + 2)-king.
y();
 
 1002   const int king_x = (king.
x() > 5 ? 10 - king.
x() : king.
x());
 
 1003   const int king_y = (Defense == 
BLACK ? king.
y() : 10 - king.
y());
 
 1004   if ((Defense == 
BLACK && king.
x() >= 6) ||
 
 1005       (Defense == 
WHITE && king.
x() >= 5)){
 
 1006     for (
int dx = min_dx; dx <= max_dx; ++dx)
 
 1012         for (
int dy = min_dy; dy <= max_dy; ++dy)
 
 1016             const int rel_y = dy * (Defense == 
BLACK ? 1 : -1);
 
 1018             index<Defense>(state, 
target, index_xy,
 
 1019                            rel_y,king_x,king_y,x_diff);
 
 1020             out += xy_table[index_xy];
 
 1025     for (
int dx = min_dx; dx <= max_dx; ++dx)
 
 1031         for (
int dy = min_dy; dy <= max_dy; ++dy)
 
 1035             const int rel_y = dy * (Defense == 
BLACK ? 1 : -1);
 
 1037             index<Defense>(state, 
target, index_xy,
 
 1038                            rel_y,king_x,king_y,x_diff);
 
 1039             out +=  xy_table[index_xy];
 
 1043   if (Defense != 
BLACK)
 
 1053   evalOne<BLACK>(state, out[
BLACK]);
 
 1054   evalOne<WHITE>(state, out[
WHITE]);
 
 1059   const NumEffectState &state, 
Move last_move,
 
 1062   BoardMask mb = state.changedEffects(
BLACK), mw = state.changedEffects(
WHITE);
 
 1065   const Square kb = state.kingSquare<
BLACK>(), kw = state.kingSquare<
WHITE>();
 
 1072     evalOne<BLACK>(state, values[
BLACK]);
 
 1076     evalOne<WHITE>(state, values[
WHITE]);
 
 1081 template <
bool Opening>
 
 1084 template <
bool Opening>
 
 1088   for (
size_t i = 0; i < weights.
dimension(); ++i)
 
 1090     table[i] = weights.
value(i);
 
 1094 template <
bool Opening>
 
 1095 template <osl::Player player>
 
 1100   if ((player == 
BLACK && king.
x() >= 6) ||
 
 1101       (player == 
WHITE && king.
x() >= 5))
 
 1104     target_x = 10 - target.
x();
 
 1109     target_x = target.
x();
 
 1111   const int y = (player == 
BLACK ? king.
y() : 10 - king.
y());
 
 1112   const int target_y = (player == 
BLACK ? target.
y() : 10 - target.
y());
 
 1114   return target_y - y + 2 + (target_x - x + 2 ) * 5 + (y - 1) * 5 * 5
 
 1115     + (x - 1) * 5 * 5 * 9;
 
 1118 template <
bool Opening>
 
 1119 template <osl::Player Defense>
 
 1125   const int min_x = 
std::max(1, king.
x() - 2);
 
 1126   const int max_x = 
std::min(9, king.
x() + 2);
 
 1127   const int min_y = 
std::max(1, king.
y() - 2);
 
 1128   const int max_y = 
std::min(9, king.
y() + 2);
 
 1129   for (
int x = min_x; x <= max_x; ++x)
 
 1131     for (
int y = min_y; y <= max_y; ++y)
 
 1136         result += table[index<Defense>(king, 
target)];
 
 1140   if (Defense == 
BLACK)
 
 1146 template <
bool Opening>
 
 1150   return evalOne<BLACK>(state) + evalOne<WHITE>(state);
 
 1153 template <
bool Opening>
 
 1169     if (std::abs(self_king.
x() - from.
x()) <= 2 &&
 
 1170         std::abs(self_king.
y() - from.
y()) <= 2)
 
 1172       result += table[index(self_king, moved.
from(), moved.
player())] *
 
 1176     if (std::abs(opp_king.
x() - from.
x()) <= 2 &&
 
 1177         std::abs(opp_king.
y() - from.
y()) <= 2)
 
 1179       result -= table[index(opp_king, from, 
alt(moved.
player()))] *
 
 1188     if (std::abs(self_king.
x() - to.
x()) <= 2 &&
 
 1189         std::abs(self_king.
y() - to.
y()) <= 2)
 
 1191       result -= table[index(self_king, to, moved.
player())] *
 
 1194     if (std::abs(opp_king.
x() - to.
x()) <= 2 &&
 
 1195         std::abs(opp_king.
y() - to.
y()) <= 2)
 
 1197       result += table[index(opp_king, to, 
alt(moved.
player()))] *
 
 1211   for (
int i = 0; i < ONE_DIM; ++i)
 
 1214       table[i][s] = weights.
value(i + ONE_DIM*s);
 
 1220   for (
int i = 0; i < X_DIM; ++i)
 
 1225   for (
int i = 0; i < Y_DIM; ++i)
 
 1232 template <osl::Player King>
 
 1236   const Square king = state.kingSquare<King>();
 
 1237   const int vertical_index =
 
 1238     index<King, VERTICAL>(
 
 1241   const int vertical_index_x =
 
 1242     indexX<King, VERTICAL>(
 
 1246   const int vertical_index_y =
 
 1247     indexY<King, VERTICAL>(
 
 1251   const int horizontal_index =
 
 1252     index<King, HORIZONTAL>(
 
 1255   const int horizontal_index_x =
 
 1256     indexX<King, HORIZONTAL>(
 
 1260   const int horizontal_index_y =
 
 1261     indexY<King, HORIZONTAL>(
 
 1265   const int diagonal_index1 =
 
 1266     index<King, DIAGONAL>(
 
 1269   const int diagonal_index2 =
 
 1270     index<King, DIAGONAL>(
 
 1273   const int diagonal_index1_x =
 
 1274     indexX<King, DIAGONAL>(
 
 1278   const int diagonal_index2_x=
 
 1279     indexX<King, DIAGONAL>(
 
 1283   const int diagonal_index1_y =
 
 1284     indexY<King, DIAGONAL>(
 
 1288   const int diagonal_index2_y =
 
 1289     indexY<King, DIAGONAL>(
 
 1293   const MultiInt v = value(vertical_index, horizontal_index,
 
 1294                             diagonal_index1, diagonal_index2,
 
 1295                             vertical_index_x,  horizontal_index_x,
 
 1296                             diagonal_index1_x, diagonal_index2_x,
 
 1297                             vertical_index_y , horizontal_index_y,
 
 1298                             diagonal_index1_y, diagonal_index2_y);
 
 1313   evalOne<BLACK>(state, 
result);
 
 1314   evalOne<WHITE>(state, 
result);
 
 1320   const NumEffectState &state,
 
 1324   const CArray<Square,2> kings = {{ 
 
 1325       state.kingSquare(
BLACK),
 
 1326       state.kingSquare(
WHITE),
 
 1328   if ((std::abs(last_move.
to().
x() - kings[0].x()) <= 1 &&
 
 1329        std::abs(last_move.
to().
y() - kings[0].y()) <= 1) ||
 
 1330       (std::abs(last_move.
to().
x() - kings[1].x()) <= 1 &&
 
 1331        std::abs(last_move.
to().
y() - kings[1].y()) <= 1))
 
 1335     if ((std::abs(last_move.
from().
x() - kings[0].x()) <= 1 &&
 
 1336          std::abs(last_move.
from().
y() - kings[0].y()) <= 1) ||
 
 1337         (std::abs(last_move.
from().
x() - kings[1].x()) <= 1 &&
 
 1338          std::abs(last_move.
from().
y() - kings[1].y()) <= 1))
 
 1360   static CArray<MultiInt, 3240> old_table;
 
 1361   for (
int i = 0; i < ONE_DIM; ++i)
 
 1364       old_table[i][s] = weights.
value(i + ONE_DIM*s);
 
 1366   for(
int king_x=0;king_x<5;king_x++)
 
 1367     for(
int king_y=0;king_y<9;king_y++)
 
 1368       for(
int dir=0;dir<8;dir++)
 
 1369         for(
int mobility=0;mobility<9;mobility++){
 
 1370           int oldIndex=king_x + 5 * (king_y + 9 * (dir + 8 * mobility));
 
 1371           int newIndex=mobility+9*(dir+8*(king_y+9*king_x));
 
 1373             table[newIndex][s]=old_table[oldIndex][s];
 
 1380   static CArray<MultiInt, 3240> old_table;
 
 1381   for (
int i = 0; i < ONE_DIM; ++i)
 
 1384       old_table[i][s] = weights.
value(i + ONE_DIM*s);
 
 1386   for(
int king_x=0;king_x<5;king_x++)
 
 1387     for(
int king_y=0;king_y<9;king_y++)
 
 1388       for(
int dir=0;dir<8;dir++)
 
 1389         for(
int mobility=0;mobility<9;mobility++){
 
 1390           int oldIndex=king_x + 5 * (king_y + 9 * (dir + 8 * mobility));
 
 1391           int newIndex=mobility+9*(dir+8*(king_y+9*king_x));
 
 1400   static CArray<MultiInt, 3240> old_table;
 
 1401   for (
int i = 0; i < ONE_DIM; ++i)
 
 1404       old_table[i][s] = weights.
value(i + ONE_DIM*s);
 
 1406   for(
int king_x=0;king_x<5;king_x++)
 
 1407     for(
int king_y=0;king_y<9;king_y++)
 
 1408       for(
int dir=0;dir<8;dir++)
 
 1409         for(
int mobility=0;mobility<9;mobility++){
 
 1410           int oldIndex=king_x + 5 * (king_y + 9 * (dir + 8 * mobility));
 
 1411           int newIndex=mobility+9*(dir+8*(king_y+9*king_x));
 
 1415   for(
int i=0;i<3240;i++){
 
 1423 template <osl::Player P>
 
 1428   const Square king = state.kingSquare<P>();
 
 1429   const int king_x = (king.
x() > 5 ? 10 - king.
x() : king.
x()) - 1;
 
 1430   const int king_y = (P == 
BLACK ? king.
y() : 10 - king.
y()) - 1;
 
 1431   int indexBase=9*8*(king_y+9*king_x);
 
 1433     if (state.hasPieceOnStand<
ROOK>(
alt(P)))
 
 1435       if(state.hasPieceOnStand<
BISHOP>(
alt(P))){
 
 1437           rook_bishop_table[indexBase+0*9+mobilityDir<UL>(king,state.kingMobilityAbs(P, 
UL))]+
 
 1438           rook_bishop_table[indexBase+1*9+mobilityDir<U>(king,state.kingMobilityAbs(P, 
U))]+
 
 1439           rook_bishop_table[indexBase+2*9+mobilityDir<UR>(king,state.kingMobilityAbs(P, 
UR))]+
 
 1440           rook_bishop_table[indexBase+3*9+mobilityDir<L>(king,state.kingMobilityAbs(P, 
L))]+
 
 1441           rook_bishop_table[indexBase+4*9+mobilityDir<R>(king,state.kingMobilityAbs(P, 
R))]+
 
 1442           rook_bishop_table[indexBase+5*9+mobilityDir<DL>(king,state.kingMobilityAbs(P, 
DL))]+
 
 1443           rook_bishop_table[indexBase+6*9+mobilityDir<D>(king,state.kingMobilityAbs(P, 
D))]+
 
 1444           rook_bishop_table[indexBase+7*9+mobilityDir<DR>(king,state.kingMobilityAbs(P, 
DR))];
 
 1448           rook_table[indexBase+0*9+mobilityDir<UL>(king,state.kingMobilityAbs(P, 
UL))]+
 
 1449           rook_table[indexBase+1*9+mobilityDir<U>(king,state.kingMobilityAbs(P, 
U))]+
 
 1450           rook_table[indexBase+2*9+mobilityDir<UR>(king,state.kingMobilityAbs(P, 
UR))]+
 
 1451           rook_table[indexBase+3*9+mobilityDir<L>(king,state.kingMobilityAbs(P, 
L))]+
 
 1452           rook_table[indexBase+4*9+mobilityDir<R>(king,state.kingMobilityAbs(P, 
R))]+
 
 1453           rook_table[indexBase+5*9+mobilityDir<DL>(king,state.kingMobilityAbs(P, 
DL))]+
 
 1454           rook_table[indexBase+6*9+mobilityDir<D>(king,state.kingMobilityAbs(P, 
D))]+
 
 1455           rook_table[indexBase+7*9+mobilityDir<DR>(king,state.kingMobilityAbs(P, 
DR))];
 
 1458     else if(state.hasPieceOnStand<
BISHOP>(
alt(P))){
 
 1460         bishop_table[indexBase+0*9+mobilityDir<UL>(king,state.kingMobilityAbs(P, 
UL))]+
 
 1461         bishop_table[indexBase+1*9+mobilityDir<U>(king,state.kingMobilityAbs(P, 
U))]+
 
 1462         bishop_table[indexBase+2*9+mobilityDir<UR>(king,state.kingMobilityAbs(P, 
UR))]+
 
 1463         bishop_table[indexBase+3*9+mobilityDir<L>(king,state.kingMobilityAbs(P, 
L))]+
 
 1464         bishop_table[indexBase+4*9+mobilityDir<R>(king,state.kingMobilityAbs(P, 
R))]+
 
 1465         bishop_table[indexBase+5*9+mobilityDir<DL>(king,state.kingMobilityAbs(P, 
DL))]+
 
 1466         bishop_table[indexBase+6*9+mobilityDir<D>(king,state.kingMobilityAbs(P, 
D))]+
 
 1467         bishop_table[indexBase+7*9+mobilityDir<DR>(king,state.kingMobilityAbs(P, 
DR))];
 
 1471         table[indexBase+0*9+mobilityDir<UL>(king,state.kingMobilityAbs(P, 
UL))]+
 
 1472         table[indexBase+1*9+mobilityDir<U>(king,state.kingMobilityAbs(P, 
U))]+
 
 1473         table[indexBase+2*9+mobilityDir<UR>(king,state.kingMobilityAbs(P, 
UR))]+
 
 1474         table[indexBase+3*9+mobilityDir<L>(king,state.kingMobilityAbs(P, 
L))]+
 
 1475         table[indexBase+4*9+mobilityDir<R>(king,state.kingMobilityAbs(P, 
R))]+
 
 1476         table[indexBase+5*9+mobilityDir<DL>(king,state.kingMobilityAbs(P, 
DL))]+
 
 1477         table[indexBase+6*9+mobilityDir<D>(king,state.kingMobilityAbs(P, 
D))]+
 
 1478         table[indexBase+7*9+mobilityDir<DR>(king,state.kingMobilityAbs(P, 
DR))];
 
 1482     if (state.hasPieceOnStand<
ROOK>(
alt(P)))
 
 1484       if(state.hasPieceOnStand<
BISHOP>(
alt(P))){
 
 1486           rook_bishop_table[indexBase+7*9+mobilityDir<UL>(king,state.kingMobilityAbs(P, 
UL))]+
 
 1487           rook_bishop_table[indexBase+6*9+mobilityDir<U>(king,state.kingMobilityAbs(P, 
U))]+
 
 1488           rook_bishop_table[indexBase+5*9+mobilityDir<UR>(king,state.kingMobilityAbs(P, 
UR))]+
 
 1489           rook_bishop_table[indexBase+4*9+mobilityDir<L>(king,state.kingMobilityAbs(P, 
L))]+
 
 1490           rook_bishop_table[indexBase+3*9+mobilityDir<R>(king,state.kingMobilityAbs(P, 
R))]+
 
 1491           rook_bishop_table[indexBase+2*9+mobilityDir<DL>(king,state.kingMobilityAbs(P, 
DL))]+
 
 1492           rook_bishop_table[indexBase+1*9+mobilityDir<D>(king,state.kingMobilityAbs(P, 
D))]+
 
 1493           rook_bishop_table[indexBase+0*9+mobilityDir<DR>(king,state.kingMobilityAbs(P, 
DR))]);
 
 1497           rook_table[indexBase+7*9+mobilityDir<UL>(king,state.kingMobilityAbs(P, 
UL))]+
 
 1498           rook_table[indexBase+6*9+mobilityDir<U>(king,state.kingMobilityAbs(P, 
U))]+
 
 1499           rook_table[indexBase+5*9+mobilityDir<UR>(king,state.kingMobilityAbs(P, 
UR))]+
 
 1500           rook_table[indexBase+4*9+mobilityDir<L>(king,state.kingMobilityAbs(P, 
L))]+
 
 1501           rook_table[indexBase+3*9+mobilityDir<R>(king,state.kingMobilityAbs(P, 
R))]+
 
 1502           rook_table[indexBase+2*9+mobilityDir<DL>(king,state.kingMobilityAbs(P, 
DL))]+
 
 1503           rook_table[indexBase+1*9+mobilityDir<D>(king,state.kingMobilityAbs(P, 
D))]+
 
 1504           rook_table[indexBase+0*9+mobilityDir<DR>(king,state.kingMobilityAbs(P, 
DR))]);
 
 1507     else if(state.hasPieceOnStand<
BISHOP>(
alt(P))){
 
 1509         bishop_table[indexBase+7*9+mobilityDir<UL>(king,state.kingMobilityAbs(P, 
UL))]+
 
 1510         bishop_table[indexBase+6*9+mobilityDir<U>(king,state.kingMobilityAbs(P, 
U))]+
 
 1511         bishop_table[indexBase+5*9+mobilityDir<UR>(king,state.kingMobilityAbs(P, 
UR))]+
 
 1512         bishop_table[indexBase+4*9+mobilityDir<L>(king,state.kingMobilityAbs(P, 
L))]+
 
 1513         bishop_table[indexBase+3*9+mobilityDir<R>(king,state.kingMobilityAbs(P, 
R))]+
 
 1514         bishop_table[indexBase+2*9+mobilityDir<DL>(king,state.kingMobilityAbs(P, 
DL))]+
 
 1515         bishop_table[indexBase+1*9+mobilityDir<D>(king,state.kingMobilityAbs(P, 
D))]+
 
 1516         bishop_table[indexBase+0*9+mobilityDir<DR>(king,state.kingMobilityAbs(P, 
DR))]);
 
 1520         table[indexBase+7*9+mobilityDir<UL>(king,state.kingMobilityAbs(P, 
UL))]+
 
 1521         table[indexBase+6*9+mobilityDir<U>(king,state.kingMobilityAbs(P, 
U))]+
 
 1522         table[indexBase+5*9+mobilityDir<UR>(king,state.kingMobilityAbs(P, 
UR))]+
 
 1523         table[indexBase+4*9+mobilityDir<L>(king,state.kingMobilityAbs(P, 
L))]+
 
 1524         table[indexBase+3*9+mobilityDir<R>(king,state.kingMobilityAbs(P, 
R))]+
 
 1525         table[indexBase+2*9+mobilityDir<DL>(king,state.kingMobilityAbs(P, 
DL))]+
 
 1526         table[indexBase+1*9+mobilityDir<D>(king,state.kingMobilityAbs(P, 
D))]+
 
 1527         table[indexBase+0*9+mobilityDir<DR>(king,state.kingMobilityAbs(P, 
DR))]);
 
 1545   CArray<MultiInt, 2925> old_table;
 
 1546   for (
int i = 0; i < ONE_DIM; ++i)
 
 1549       old_table[i][s] = weights.
value(i + ONE_DIM*s);
 
 1551   for(
int king_x=0;king_x<5;king_x++)
 
 1552     for(
int king_y=0;king_y<9;king_y++)
 
 1553       for(
int mobility=0;mobility<=32;mobility++){
 
 1554         int oldIndex=king_x+5*(king_y+9*(mobility+8));
 
 1555         int newIndex=mobility+33*(king_y+9*king_x);
 
 1557           table[newIndex]=old_table[oldIndex];
 
 1561 template <osl::Player P>
 
 1566   const Square king = state.kingSquare<P>();
 
 1567   int sum=state.kingMobilityAbs(P, 
UL).
y()+state.kingMobilityAbs(P, 
U).y()+
 
 1568     state.kingMobilityAbs(P, 
UR).y()+state.kingMobilityAbs(P, 
R).x()-
 
 1569     state.kingMobilityAbs(P, 
DL).y()-state.kingMobilityAbs(P, 
D).y()-
 
 1570     state.kingMobilityAbs(P, 
DR).y()-state.kingMobilityAbs(P, 
L).x();
 
 1571   const int king_x = (king.
x() > 5 ? 10 - king.
x() : king.
x()) - 1;
 
 1572   const int king_y = (P == 
BLACK ? king.
y() : 10 - king.
y()) - 1;
 
 1574   result = table[mobility+33*(king_y+9*king_x)];
 
 1602   for (
int i = 0; i < ONE_DIM; ++i)
 
 1605       table[i][s] = weights.
value(i + ONE_DIM*s);
 
 1611   for (
int i = 0; i < ONE_DIM; ++i)
 
 1620   for (
int i = 0; i < ONE_DIM; ++i)
 
 1625   for(
int king_y=1;king_y<=9;king_y++)
 
 1626     for(
int effect1=0;effect1<32;effect1++)
 
 1627       for(
int effect2=0;effect2<32;effect2++)
 
 1628         for(
int i=0;i<8;i++){
 
 1629           int index0=effect1 + 32 * (effect2 + 32 * i);
 
 1630           int index1=king_y - 1 + 9 *(effect1 + 32 * (effect2 + 32 * i));
 
 1635 template<osl::Player P>
 
 1638                         const CArray<int, 5> &effects)
 
 1640   const Square king=state.kingSquare<P>();
 
 1641   const int king_y = (P==
BLACK ? king.
y() : 10 - king.
y());
 
 1642   const int king_x = (king.
x() >= 6 ? 10 - king.
x() : king.
x());
 
 1643   if ((P== 
BLACK && king.
x() > 5) || (P==
WHITE && king.
x() < 5)){
 
 1645       x_table[indexX(king_x,effects[2],effects[0],(2*3)+1)]+ 
 
 1646       y_table[indexY(king_y,effects[0],effects[2],(0*3)+0)]+
 
 1647       x_table[indexX(king_x,effects[3],effects[0],(1*3)+2)]+ 
 
 1648       y_table[indexY(king_y,effects[0],effects[3],(0*3)+1)]+
 
 1649       x_table[indexX(king_x,effects[4],effects[0],(0*3)+2)]+ 
 
 1650       y_table[indexY(king_y,effects[0],effects[4],(0*3)+2)]+
 
 1651       x_table[indexX(king_x,effects[2],effects[1],(2*3)+0)]+ 
 
 1652       y_table[indexY(king_y,effects[1],effects[2],(1*3)+0)]+
 
 1653       x_table[indexX(king_x,effects[3],effects[1],(1*3)+1)]+ 
 
 1654       y_table[indexY(king_y,effects[1],effects[3],(1*3)+1)]+
 
 1655       x_table[indexX(king_x,effects[4],effects[1],(0*3)+1)]+ 
 
 1656       y_table[indexY(king_y,effects[1],effects[4],(1*3)+2)]+
 
 1657       x_table[indexX(king_x,effects[3],effects[2],(1*3)+0)]+ 
 
 1658       y_table[indexY(king_y,effects[2],effects[3],(2*3)+0)]+
 
 1659       x_table[indexX(king_x,effects[4],effects[2],(0*3)+0)]+ 
 
 1660       y_table[indexY(king_y,effects[2],effects[4],(2*3)+1)];
 
 1664       x_table[indexX(king_x,effects[0],effects[2],(0*3)+0)]+ 
 
 1665       y_table[indexY(king_y,effects[0],effects[2],(0*3)+0)]+
 
 1666       x_table[indexX(king_x,effects[0],effects[3],(0*3)+1)]+ 
 
 1667       y_table[indexY(king_y,effects[0],effects[3],(0*3)+1)]+
 
 1668       x_table[indexX(king_x,effects[0],effects[4],(0*3)+2)]+ 
 
 1669       y_table[indexY(king_y,effects[0],effects[4],(0*3)+2)]+
 
 1670       x_table[indexX(king_x,effects[1],effects[2],(1*3)+0)]+ 
 
 1671       y_table[indexY(king_y,effects[1],effects[2],(1*3)+0)]+
 
 1672       x_table[indexX(king_x,effects[1],effects[3],(1*3)+1)]+ 
 
 1673       y_table[indexY(king_y,effects[1],effects[3],(1*3)+1)]+
 
 1674       x_table[indexX(king_x,effects[1],effects[4],(1*3)+2)]+ 
 
 1675       y_table[indexY(king_y,effects[1],effects[4],(1*3)+2)]+
 
 1676       x_table[indexX(king_x,effects[2],effects[3],(2*3)+0)]+ 
 
 1677       y_table[indexY(king_y,effects[2],effects[3],(2*3)+0)]+
 
 1678       x_table[indexX(king_x,effects[2],effects[4],(2*3)+1)]+ 
 
 1679       y_table[indexY(king_y,effects[2],effects[4],(2*3)+1)];
 
 1685                      const CArray<int, 5> &black,
 
 1686                      const CArray<int, 5> &white)
 
 1688   return evalOne<BLACK>(state,black)-evalOne<WHITE>(state,white);
 
 1698   for (
int i = 0; i < ONE_DIM; ++i)
 
 1701       table[i][s] = weights.
value(i + ONE_DIM*s);
 
 1707   for (
int i = 0; i < ONE_DIM; ++i)
 
 1714 template <osl::Player Attack>
 
 1719   king25 = king25 & state.piecesOnBoard(Attack);
 
 1720   const PieceMask promoted_mask = (king25 & state.promotedPieces());
 
 1721   const bool with_knight =
 
 1722     (king25 & ~state.promotedPieces()).
template selectBit<KNIGHT>().any();
 
 1723   king25.clearBit<
KNIGHT>();
 
 1724   king25.clearBit<
LANCE>();
 
 1725   king25.clearBit<
PAWN>();
 
 1726   king25 = king25 | promoted_mask;
 
 1727   const int piece_count = 
std::min(9, king25.countBit());
 
 1728   const int stand_count = 
std::min(9,
 
 1729                                    state.countPiecesOnStand<
ROOK>(Attack) +
 
 1730                                    state.countPiecesOnStand<
BISHOP>(Attack) +
 
 1731                                    state.countPiecesOnStand<
GOLD>(Attack) +
 
 1732                                    state.countPiecesOnStand<
SILVER>(Attack));
 
 1733   const bool stand_with_knight = state.hasPieceOnStand<
KNIGHT>(Attack);
 
 1735   PieceMask attacked =
 
 1736     state.effectedMask(Attack) & state.piecesOnBoard(Defense);
 
 1737   attacked.clearBit<
KNIGHT>();
 
 1738   attacked.clearBit<
LANCE>();
 
 1739   attacked.clearBit<
PAWN>();
 
 1740   PieceMask attacking;
 
 1741   while (attacked.any())
 
 1743     const Piece piece = state.pieceOf(attacked.takeOneBit());
 
 1744     attacking = attacking | state.effectSetAt(piece.
square());
 
 1746   attacking = (attacking & state.piecesOnBoard(Attack) & ~king25);
 
 1747   const int attacked_count = 
std::min(5, attacking.countBit());
 
 1748   if (Attack == 
BLACK)
 
 1750     return table[index(piece_count, with_knight,
 
 1751                        stand_count, stand_with_knight, attacked_count)] +
 
 1752       y_table[indexY(piece_count, with_knight,
 
 1753                      stand_count, stand_with_knight, attacked_count,
 
 1754                      state.kingSquare<
WHITE>().y())];
 
 1758     return -(table[index(piece_count, with_knight,
 
 1759                          stand_count, stand_with_knight, attacked_count)] +
 
 1760              y_table[indexY(piece_count, with_knight,
 
 1761                             stand_count, stand_with_knight, attacked_count,
 
 1762                             10 - state.kingSquare<
BLACK>().y())]);
 
 1768                     const CArray<PieceMask, 2> &king25_mask)
 
 1770   return evalOne<BLACK>(state, king25_mask[
WHITE]) +
 
 1771     evalOne<WHITE>(state, king25_mask[
BLACK]);
 
 1784   for (
int i = 0; i < ONE_DIM; ++i)
 
 1787       table[i][s] = weights.
value(i + ONE_DIM*s);
 
 1793   for (
int i = 0; i < ONE_DIM; ++i)
 
 1802   for (
int i = 0; i < ONE_DIM; ++i)
 
 1811                      const CArray<int, 5> &black,
 
 1812                      const CArray<int, 5> &white)
 
 1814   const CArray<Square,2> kings = {{ 
 
 1815       state.kingSquare<
BLACK>(),
 
 1816       state.kingSquare<
WHITE>(),
 
 1819   for (
size_t i = 1; i < black.size(); ++i)
 
 1821     result += (table[index(black[i - 1], black[i], i - 1)] +
 
 1823                                      black[i - 1], black[i], i - 1)] +
 
 1825                                      black[i - 1], black[i], i - 1)]);
 
 1826     result -= (table[index(white[i - 1], white[i], i - 1)] +
 
 1828                                      white[i - 1], white[i], i - 1)] +
 
 1830                                      white[i - 1], white[i], i - 1)]);
 
 1843   for (
int i = 0; i < ONE_DIM; ++i)
 
 1846       table[i][s] = weights.
value(i + ONE_DIM*s);
 
 1852   for (
int i = 0; i < ONE_DIM; ++i)
 
 1859 template <osl::Player Attack>
 
 1865   PieceMask attack = king25 & state.piecesOnBoard(Attack);
 
 1867     king25 & state.piecesOnBoard(Defense);
 
 1868   const PieceMask attack_promoted_mask = (attack & state.promotedPieces());
 
 1869   const PieceMask defense_promoted_mask = (defense & state.promotedPieces());
 
 1870   attack.clearBit<
KNIGHT>();
 
 1871   attack.clearBit<
LANCE>();
 
 1872   attack.clearBit<
PAWN>();
 
 1873   attack = attack | attack_promoted_mask;
 
 1874   defense.clearBit<
KNIGHT>();
 
 1875   defense.clearBit<
LANCE>();
 
 1876   defense.clearBit<
PAWN>();
 
 1877   defense = defense | defense_promoted_mask;
 
 1878   const int attack_count = 
std::min(9,
 
 1880                                     state.countPiecesOnStand<
ROOK>(Attack) +
 
 1881                                     state.countPiecesOnStand<
BISHOP>(Attack) +
 
 1882                                     state.countPiecesOnStand<
GOLD>(Attack) +
 
 1883                                     state.countPiecesOnStand<
SILVER>(Attack));
 
 1884   const int defense_count = 
std::min(9,
 
 1885                                     defense.countBit() +
 
 1886                                     state.countPiecesOnStand<
ROOK>(Defense) +
 
 1887                                     state.countPiecesOnStand<
BISHOP>(Defense) +
 
 1888                                     state.countPiecesOnStand<
GOLD>(Defense) +
 
 1889                                     state.countPiecesOnStand<
SILVER>(Defense));
 
 1890   const int y = (Attack == 
BLACK ? state.kingSquare<Defense>().y() :
 
 1891                  10 - state.kingSquare<Defense>().y());
 
 1893     y_table[y - 1 + 9 * (attack_count + 10 * defense_count)];
 
 1894   if (Attack == 
BLACK)
 
 1902                                    const CArray<PieceMask, 2> &king25_mask)
 
 1904   return evalOne<BLACK>(state, king25_mask[
WHITE]) +
 
 1905     evalOne<WHITE>(state, king25_mask[
BLACK]);
 
 1913   for (
size_t i=0; i<weights.
dimension(); ++i)
 
 1914     table[i] = weights.
value(i);
 
 1920   if (state.promotedPieces().any())
 
 1922   PieceMask stand_all = state.standMask(
BLACK) | state.standMask(
WHITE);
 
 1923   stand_all.clearBit<
BISHOP>();
 
 1924   stand_all.clearBit<
PAWN>();
 
 1925   if (stand_all.any())
 
 1927   if (state.nth<
BISHOP>(0).owner() == state.nth<
BISHOP>(1).owner())
 
 1929   if (state.nth<
BISHOP>(0).isOnBoard() != state.nth<
BISHOP>(1).isOnBoard())
 
 1932   if (state.nth<
BISHOP>(0).isOnBoard()) {
 
 1933     offset += BISHOP_ONE_DIM;
 
 1934     if (state.hasEffectByPiece(state.nth<
BISHOP>(0),
 
 1935                                state.nth<
BISHOP>(1).square()))
 
 1936       offset += BISHOP_ONE_DIM;
 
 1938   return evalOne<BLACK>(state, offset) + evalOne<WHITE>(state, offset);
 
 1941 template <osl::Player KingOwner>
 
 1945   Square king = state.kingSquare(KingOwner);
 
 1949   CArray<Piece,2> rook = {{
 
 1952   if (rook[0].owner() == rook[1].owner())
 
 1954   if (rook[0].owner() == KingOwner)
 
 1955     std::swap(rook[0], rook[1]);
 
 1956   int rook_index0 = indexKing(rook[0].square().squareForBlack(KingOwner)); 
 
 1957   if (rook_index0 < 0)
 
 1959   int rook_index1 = indexKing(rook[1].square().squareForBlack(
alt(KingOwner))); 
 
 1960   if (rook_index1 < 0)
 
 1962   FixedCapacityVector<Square, 4> silver;
 
 1963   for (
int i=0; i<state.nthLimit<
SILVER>(); ++i) {
 
 1966     if (p.
owner() == KingOwner)
 
 1970   if (silver.size() != 2 || silver[0].x() == silver[1].x())
 
 1973     = indexSilver((silver[0].x() > silver[1].x()) ? silver[0] : silver[1]);
 
 1974   int index = offset + (king_index*81+silver_index)*90;
 
 1975   return table[index + rook_index0] * 
playerToMul(KingOwner)
 
 1976     + table[index + 45 + rook_index1] * 
playerToMul(KingOwner);
 
 1982 template <osl::Player KingOwner>
 
 1986   Square king = state.kingSquare(KingOwner);
 
 1987   if (king.
y() < 4 || king.
y() > 6) 
 
 1989   CArray2d<int, 2, 2> 
count = {{{ 0 }}};
 
 2010   return evalOne<BLACK>(state) + evalOne<WHITE>(state);
 
 2017   for (
size_t i=0; i<weights.
dimension(); ++i)
 
 2018     table[i] = weights.
value(i);
 
 2029       template MultiInt KingPieceRelative::
 
 2030       evalWithUpdate<BLACK>(
const NumEffectState &state,
 
 2032       template MultiInt KingPieceRelative::
 
 2033       evalWithUpdate<WHITE>(
const NumEffectState &state,
 
 2042       template void King25EffectBoth::countEffectAndPiecesBoth<BLACK>(
const NumEffectState&, PieceMask&, PieceMask&, 
int&, 
int&, 
int&, 
int&, 
int&, CArray<int, 5>&, CArray<int, 5>&);
 
 2043       template void King25EffectBoth::countEffectAndPiecesBoth<WHITE>(
const NumEffectState&, PieceMask&, PieceMask&, 
int&, 
int&, 
int&, 
int&, 
int&, CArray<int, 5>&, CArray<int, 5>&);