17   for (
int x=1; x<=9; ++x) {
 
   18     for (
int y=1; y<=9; ++y) {
 
   19       const Square position(x,y);
 
   28   const NumEffectState& state = *info.
state;
 
   32   const CArray<Square,2> kings = {{
 
   33       state.kingSquare(
BLACK),
 
   34       state.kingSquare(
WHITE),
 
   36   const Player turn = state.turn();
 
   44   std::pair<Ptype,Ptype> pair;
 
   48   int effect9 = classifyEffect9(state, turn, position);
 
   49   cache[cur++] = basic + pair.first;
 
   50   cache[cur++] = basic + AttackBase + pair.second;
 
   51   cache[cur++] = basic + EffectBase + effect9;
 
   58       cache[cur++] = basic + AttackBase + 
PTYPE_EDGE;
 
   60   assert(basic + EffectBase + effect9 < PatternCacheSize);
 
   61   int op_king_distance = abs(kings[
alt(turn)].x()-position.
x())
 
   62     + abs(kings[
alt(turn)].y()-position.
y());
 
   63   if (op_king_distance == 0) 
 
   64     op_king_distance = state.king8Info(
alt(turn)).libertyCount();
 
   67   if (op_king_distance < OpKingSize)
 
   68     cache[cur++] = basic + OpKingBase + op_king_distance;
 
   69   int my_king_distance = abs(kings[turn].x()-position.
x())
 
   70     + abs(kings[turn].y()-position.
y());
 
   71   if (my_king_distance == 0) 
 
   72     my_king_distance = state.king8Info(turn).libertyCount();
 
   75   if (my_king_distance < MyKingSize)
 
   76     cache[cur++] = basic + MyKingBase + my_king_distance;
 
   79     cache[cur++] = basic + PromotionBase;
 
   81     cache[cur++] = basic + PromotionBase + 1;
 
   84     if (state.pinOrOpen(turn).test(target.
number()))
 
   85       cache[cur++] = basic + PinOpenBase + (target.
owner() == turn);
 
   86     if (state.pinOrOpen(
alt(turn)).test(target.
number()))
 
   87       cache[cur++] = basic + PinOpenBase + 2 + (target.
owner() == 
alt(turn));
 
   89     if (info.
history->hasLastMove()) {
 
   90       if (info.
history->lastMove().to() == position)
 
   91         cache[cur++] = basic + LastToBase;
 
   92       for (
int i=1; i<4; ++i) {
 
   93         if (! info.
history->hasLastMove(i+1))
 
   95         if (info.
history->lastMove(i+1).to() == position)
 
   96           cache[cur++] = basic + LastToBase + i;
 
  101   if (info.
history->hasLastMove()) {
 
  103       cache[cur++] = basic + LastEffectChangedBase;
 
  106       cache[cur++] = basic + LastEffectChangedBase + ptype_index;
 
  116   const NumEffectState& state = *info.
state;
 
  118        i<PtypeTraits<LANCE>::indexLimit; ++i) {
 
  119     const Piece p = state.pieceOf(i);
 
  123     makeLongAttackOne(info, p, d);
 
  126        i<PtypeTraits<BISHOP>::indexLimit; ++i) {
 
  127     const Piece p = state.pieceOf(i);
 
  130     makeLongAttackOne(info, p, 
UL);
 
  131     makeLongAttackOne(info, p, 
UR);
 
  132     makeLongAttackOne(info, p, 
DL);
 
  133     makeLongAttackOne(info, p, 
DR);
 
  136        i<PtypeTraits<ROOK>::indexLimit; ++i) {
 
  137     const Piece p = state.pieceOf(i);
 
  140     makeLongAttackOne(info, p, 
L);
 
  141     makeLongAttackOne(info, p, 
R);
 
  142     makeLongAttackOne(info, p, 
U);
 
  143     makeLongAttackOne(info, p, 
D);
 
  151   const NumEffectState& state = *info.
state;
 
  154   const Player turn = state.turn();
 
  158   Square attack_to2 = attack_to;
 
  159   assert(! attack_to.isPieceStand());
 
  160   if (attack_to.isEdge())
 
  165     if (state.pieceAt(attack_to2).isEmpty()) {
 
  168       } 
while (state.pieceAt(attack_to2).isEmpty());
 
  169       if (state.pieceAt(attack_to2).isEdge())
 
  173   PtypeO attacked = state.pieceOnBoard(attack_to).ptypeO();
 
  175     attacked = 
alt(attacked);
 
  176   int index = (longAttackIndex(attacking)*
PTYPEO_SIZE 
  178   out.push_back(index);
 
  180     out.push_back(index + 1); 
 
  181   if (! state.hasEffectAt(turn, attack_to))
 
  182     out.push_back(index + 2); 
 
  183   if (attack_to.canPromote(
alt(turn)))
 
  184     out.push_back(index + 3); 
 
  185   Piece attacked2 = state.pieceAt(attack_to2);
 
  187     out.push_back(index + 4); 
 
  188     if (! state.hasEffectAt(turn, attack_to2))
 
  189       out.push_back(index + 5); 
 
  191       out.push_back(index + 6); 
 
  196     if (threat_at == attack_to
 
  199                                      piece.
square(), attack_to)))
 
  200       out.push_back(index + 7);