34     const CArray<int,19*9> yss_bonus = {{
 
   36       50,  50,  50,  50,  50,  50,  0,  0,  0,
 
   37       50,  50,  50,  50,  50,  50,  0,  0,  0,
 
   38       56,  53,  50,  50,  50,  50,  0,  0,  0,
 
   39       64,  61,  55,  50,  50,  50,  0,  0,  0,
 
   40       79,  77,  70,  65,  54,  51,  0,  0,  0,
 
   41      100,  99,  95,  87,  74,  58,  0,  0,  0,
 
   42      116, 117, 101,  95,  88,  67,  0,  0,  0,
 
   43      131, 129, 124, 114,  90,  71,  0,  0,  0,
 
   44      137, 138, 132, 116,  96,  76,  0,  0,  0,
 
   45      142, 142, 136, 118,  98,  79,  0,  0,  0,
 
   46      132, 132, 129, 109,  95,  75,  0,  0,  0,
 
   47      121, 120, 105,  97,  84,  66,  0,  0,  0,
 
   48       95,  93,  89,  75,  68,  58,  0,  0,  0,
 
   49       79,  76,  69,  60,  53,  50,  0,  0,  0,
 
   50       64,  61,  55,  51,  50,  50,  0,  0,  0,
 
   51       56,  52,  50,  50,  50,  50,  0,  0,  0,
 
   52       50,  50,  50,  50,  50,  50,  0,  0,  0,
 
   53       50,  50,  50,  50,  50,  50,  0,  0,  0,
 
   54       50,  50,  50,  50,  50,  50,  0,  0,  0,
 
   57     const CArray<int,9> yss_king_bonus = {{
 
   58       0, 0, 0, 150, 450, 900,1300,1550,1600
 
   60     inline int toEven(
int value) 
 
   68     inline int multiply(
int value, 
int bonus)
 
   74         bonus = (bonus - 100)/3 + 100;
 
   76       return toEven(value * bonus / 120);
 
   78     inline void adhoc_adjust(
int& value, 
double scale)
 
   80       value = toEven(static_cast<int>(value * scale));
 
   92   for (
int king_x=1; king_x<=9; ++king_x)
 
   94     for (
int king_y=1; king_y<=9; ++king_y)
 
   96       const Square king(king_x, king_y);
 
  103         const int ptype_value
 
  106         const int stand_bonus
 
  117         if (basic_type == 
KING)
 
  121             = ptype_value + yss_king_bonus[9-king_y];
 
  125         for (
int defense_x=1; defense_x<=9; ++defense_x)
 
  128             = (((defense_x < 3) && (defense_x < king_x))
 
  129                || ((defense_x > 7) && (defense_x > king_x)));
 
  130           const int relative_x = abs(king_x - defense_x);
 
  131           for (
int defense_y=1; defense_y<=9; ++defense_y)
 
  133             const Square defender(defense_x, defense_y);
 
  141               else if (king_y == 4)
 
  144               else if (basic_type == 
ROOK && defense_y == 8 && king_y >= 8)
 
  150                 multiply(ptype_value, black_bonus);
 
  153             int relative_y_black_king = king_y - defense_y;
 
  157               relative_y_black_king++;
 
  159             else if (ptype == 
PAWN)
 
  162               if (relative_y_black_king == 1)
 
  164                 relative_y_black_king = 2;
 
  166               else if (relative_y_black_king == 2)
 
  168                 relative_y_black_king = 1;
 
  173               = yss_bonus[relative_x + (-relative_y_black_king+9)*9];
 
  175             if (near_edge || ptype == 
LANCE)
 
  177               if (!(ptype == 
PAWN &&
 
  178                     (defense_x == 1 || defense_x == 9) &&
 
  180                 bonus_black_king = 
std::min(100, bonus_black_king);
 
  184               if ((defense_x == 2 || defense_x == 8) &&
 
  185                   (defense_y == 1 || defense_y == 9))
 
  190                 bonus_black_king = 
std::min(100, bonus_black_king);
 
  194             int black_defense =  multiply(ptype_value,bonus_black_king);
 
  195             const bool near_center 
 
  196               = abs(defense_x-king_x)==1 &&
 
  197               (((king_x < 3) && (defense_x > king_x))
 
  198                || ((king_x > 7) && (defense_x < king_x)));
 
  199             if(defense_x==king_x || near_center){
 
  200               if(defense_y==king_y-1){
 
  201                 if(king_y==9 && (king_x==1 || king_x==9))
 
  203                 else if(defense_x!=king_x && king_y==8 && (king_x==2 || king_x==8))
 
  216   for (
int king_x=1; king_x<=9; ++king_x)
 
  218     for (
int king_y=1; king_y<=9; ++king_y)
 
  220       const Square king(king_x, king_y);
 
  221       for (
int x=1; x<=9; ++x)
 
  266   for (
int king_x=1; king_x<=9; ++king_x) {
 
  267     for (
int king_y=1; king_y<=9; ++king_y) {
 
  268       const Square king_b(king_x, king_y);
 
  280         for (
int defense_x=1; defense_x<=9; ++defense_x) {
 
  281           for (
int defense_y=1; defense_y<=9; ++defense_y) {
 
  282             const Square defense_b(defense_x, defense_y);