34   for (
size_t i = 0; i < 9; ++i)
 
   36     RookMobilityAll::rook_vertical_table[i][stage] = weights.
value(i);
 
   38   for (
size_t i = 0; i < 9; ++i)
 
   40     RookMobilityAll::rook_horizontal_table[i][stage] = weights.
value(i + 9);
 
   42   for (
size_t i = 0; i < 9; ++i)
 
   44     RookMobilityAll::rook_vertical_table[i+9][stage] = weights.
value(i + 18);
 
   46   for (
size_t i = 0; i < 9; ++i)
 
   48     RookMobilityAll::rook_horizontal_table[i+9][stage] = weights.
value(i + 27);
 
   55   for (
size_t i = 0; i < ONE_DIM; ++i)
 
   58       RookMobilityAll::sum_table[i][s] = weights.
value(i + ONE_DIM*s);
 
   65   for (
size_t i = 0; i < ONE_DIM; ++i)
 
   75   for (
size_t i = 0; i < ONE_DIM; ++i)
 
   85   for (
size_t i = 0; i < ONE_DIM; ++i)
 
   88       RookMobilityAll::xkingx_table[i][s] = weights.
value(i + ONE_DIM*s);
 
   94   for (
size_t i = 0; i < ONE_DIM; ++i)
 
   97       RookMobilityAll::sumkingx_table[i][s] = weights.
value(i + ONE_DIM*s);
 
  101 template <
int Sign> 
inline 
  104                         bool promoted, 
int vertical, 
int horizontal,
 
  108   if(promoted) offset=9;
 
  113       value += (xkingx_table[indexXKingX<Sign>(position, king, vertical, 
true)]
 
  114                 + xkingx_table[indexXKingX<Sign>(position, king, horizontal, 
false)]
 
  115                 + sumkingx_table[vertical + horizontal + 17*std::abs(king.x()-position.x())]
 
  118     value+= (rook_vertical_table[vertical+offset]+
 
  119              rook_horizontal_table[horizontal+offset] +
 
  120              sum_table[vertical+horizontal+(promoted ? 17 : 0)] +
 
  121              x_table[indexX(position, promoted, vertical, 
true)] +
 
  122              x_table[indexX(position, promoted, horizontal, 
false)] +
 
  123              y_table[indexY<Sign>(position, promoted, vertical, 
true)] +
 
  124              y_table[indexY<Sign>(position, promoted, horizontal, 
false)]);
 
  129       value -= (xkingx_table[indexXKingX<Sign>(position, king, vertical, 
true)]
 
  130                 + xkingx_table[indexXKingX<Sign>(position, king, horizontal, 
false)]
 
  131                 + sumkingx_table[vertical + horizontal + 17*std::abs(king.x()-position.x())]
 
  134     value-= (rook_vertical_table[vertical+offset]+
 
  135              rook_horizontal_table[horizontal+offset] +
 
  136              sum_table[vertical+horizontal+(promoted ? 17 : 0)] +
 
  137              x_table[indexX(position, promoted, vertical, 
true)] +
 
  138              x_table[indexX(position, promoted, horizontal, 
false)] +
 
  139              y_table[indexY<Sign>(position, promoted, vertical, 
true)] +
 
  140              y_table[indexY<Sign>(position, promoted, horizontal, 
false)]);
 
  149        i < PtypeTraits<ROOK>::indexLimit;
 
  152     const Piece rook = state.pieceOf(i);
 
  157       const int vertical = osl::mobility::RookMobility::countVerticalAll<BLACK>(state,i);
 
  158       const int horizontal = osl::mobility::RookMobility::countHorizontalAll<BLACK>(
 
  164       const int vertical = osl::mobility::RookMobility::countVerticalAll<WHITE>(state,i);
 
  165       const int horizontal = osl::mobility::RookMobility::countHorizontalAll<WHITE>(
 
  178   for (
size_t i = 0; i < 18; ++i)
 
  180     BishopMobilityAll::bishop_table[i][stage] = weights.
value(i);
 
  182   for (
size_t i = 0; i < 18; ++i)
 
  184     BishopMobilityAll::bishop_table[i+18][stage] = weights.
value(i + 18);
 
  191   for (
size_t i = 0; i < ONE_DIM; ++i)
 
  194       BishopMobilityAll::each_table[i][s] = weights.
value(i + ONE_DIM*s);
 
  198 template <
int Sign> 
inline 
  212     value += (bishop_table[mobility1 + mobility2 + 
count] +
 
  213               each_table[mobility1 + each_offset] +
 
  214               each_table[mobility2 + each_offset]);
 
  218     value -= (bishop_table[mobility1 + mobility2 + 
count] +
 
  219               each_table[mobility1 + each_offset] +
 
  220               each_table[mobility2 + each_offset]);
 
  229        i < PtypeTraits<BISHOP>::indexLimit;
 
  232     const Piece bishop = state.pieceOf(i);
 
  237       const int mobility1 =
 
  238         mobility::BishopMobility::countAllDir<BLACK, UL>(state, bishop) +
 
  239         mobility::BishopMobility::countAllDir<BLACK, DR>(state, bishop);
 
  240       const int mobility2 =
 
  241         mobility::BishopMobility::countAllDir<BLACK, UR>(state, bishop) +
 
  242         mobility::BishopMobility::countAllDir<BLACK, DL>(state, bishop);
 
  247       const int mobility1 =
 
  248         mobility::BishopMobility::countAllDir<WHITE, UL>(state, bishop) +
 
  249         mobility::BishopMobility::countAllDir<WHITE, DR>(state, bishop);
 
  250       const int mobility2 =
 
  251         mobility::BishopMobility::countAllDir<WHITE, UR>(state, bishop) +
 
  252         mobility::BishopMobility::countAllDir<WHITE, DL>(state, bishop);
 
  263   for (
size_t i = 0; i < 9; ++i)
 
  265     lance_table[i][stage] = weights.
value(i);
 
  269 template <
int Sign> 
inline 
  274     value += LanceMobility::lance_table[mobility];
 
  276     value -= LanceMobility::lance_table[mobility];
 
  284        i < PtypeTraits<LANCE>::indexLimit;
 
  287     const Piece lance = state.pieceOf(i);
 
  292       const int mobility = osl::mobility::LanceMobility::countAll<BLACK>(
 
  294       adjust<1>(mobility, 
out);
 
  298       const int mobility = osl::mobility::LanceMobility::countAll<WHITE>(