11   DirectionPlayerTraits<UUL, BLACK>::offset(), 
 
   12   DirectionPlayerTraits<UL, BLACK>::offset(), 
 
   13   DirectionPlayerTraits<L, BLACK>::offset(), 
 
   14   DirectionPlayerTraits<DL, BLACK>::offset(), 
 
   15   DirectionPlayerTraits<UUR, WHITE>::offset(), 
 
   16   DirectionPlayerTraits<D, BLACK>::offset(), 
 
   18   DirectionPlayerTraits<UUL, WHITE>::offset(), 
 
   19   DirectionPlayerTraits<DR, BLACK>::offset(), 
 
   20   DirectionPlayerTraits<R, BLACK>::offset(), 
 
   21   DirectionPlayerTraits<UR, BLACK>::offset(), 
 
   22   DirectionPlayerTraits<UUR, BLACK>::offset(), 
 
   23   DirectionPlayerTraits<U, BLACK>::offset(), 
 
   46     inline int inv(
int offset_id)
 
   48       assert(offset_id >= 0 && offset_id < 12);
 
   49       return (offset_id + 6) % 12;
 
   53       assert(offset_id >= 0 && offset_id < 12);
 
   56       return 10 - offset_id;
 
   60       assert(offset_id >= 0 && offset_id < 12);
 
   68         for (
int ip1=ip0; ip1<=
PTYPE_MAX; ++ip1) {
 
   69           const Ptype p0 = 
static_cast<Ptype>(ip0), p1 = static_cast<Ptype>(ip1);
 
  150           const Ptype p0 = 
static_cast<Ptype>(ip0), p1 = static_cast<Ptype>(ip1);
 
  152           for (
int x=1; x<=5; ++x) {
 
  154             for (
int d=0; d<2; ++d) {
 
  156               x_table[x][d][pi0][pi1] = index;
 
  161             x_table[x][2][pi0][pi1] = index;
 
  164             x_table[x][11][pi0][pi1] = index;
 
  167             x_table[x][5][pi0][pi1] = index;
 
  175           const Ptype p0 = 
static_cast<Ptype>(ip0), p1 = static_cast<Ptype>(ip1);
 
  177           for (
int x=2; x<=5; ++x) {
 
  179             for (
int d=0; d<2; ++d) {
 
  197           const Ptype p0 = 
static_cast<Ptype>(ip0), p1 = static_cast<Ptype>(ip1);
 
  199           for (
int x=6; x<=9; ++x) {
 
  207       for (
int x=1; x<=9; ++x) {
 
  210             const Ptype p0 = 
static_cast<Ptype>(ip0), p1 = static_cast<Ptype>(ip1);
 
  214               assert(
x_table[x][d][pi0][pi1]);
 
  221       for (
int x=1; x<=9; ++x)
 
  235           const Ptype p0 = 
static_cast<Ptype>(ip0), p1 = static_cast<Ptype>(ip1);
 
  238           for (
int y=1; y<=9; ++y) {
 
  239             for (
int d=0; d<2; ++d) { 
 
  241               y_table[y][d][pi0][pi1] = index;
 
  246             y_table[y][2][pi0][pi1] = index;
 
  247             y_table[y][2][pi1][pi0] = index;
 
  252             y_table[y][11][pi0][pi1] = index;
 
  259           const Ptype p0 = 
static_cast<Ptype>(ip0), p1 = static_cast<Ptype>(ip1);
 
  261           for (
int y=1; y<=9; ++y) {
 
  276           const Ptype p0 = 
static_cast<Ptype>(ip0), p1 = static_cast<Ptype>(ip1);
 
  279           for (
int y=1; y<=9; ++y) {
 
  287       for (
int y=1; y<=9; ++y)
 
  293       using namespace ppair;
 
  308   for (
size_t d=0; d<offsets.size(); ++d) {
 
  311         signed short& 
target = (*this)[d][ip0][ip1];
 
  329   (*this)[dir][pi0][pi1] = index; 
 
  330   (*this)[
inv(dir)][pi0w][pi1w] = -index; 
 
  335   fillBW(index, dir, p0, p1);
 
  336   fillBW(index, 
inv(dir), p1, p0); 
 
  344   (*this)[
inv(dir)][pi0][pi1w] = index;
 
  345   (*this)[dir][pi1w][pi0] = index; 
 
  346   (*this)[
inv(dir)][pi1][pi0w] = -index; 
 
  347   (*this)[dir][pi0w][pi1] = -index; 
 
  355   static bool initialized = 
false;
 
  368   for (
int i=1; i<=9; ++i) {
 
  372   for (
size_t d=0; d<offsets.size(); ++d) {
 
  380         for (
int i=1; i<=9; ++i) {
 
  382           if (
x_table[i][d][ip0][ip1] > 0)
 
  384           else if (
x_table[i][d][ip0][ip1] < 0)
 
  386           if (
y_table[i][d][ip0][ip1] > 0)
 
  388           else if (
y_table[i][d][ip0][ip1] < 0)
 
  400   for (
int x=1; x<=9; ++x) {
 
  401     for (
int y=1; y<=9; ++y) {
 
  403       for (
size_t i=0; i<offsets.size(); ++i) {
 
  404         const Square pos0 = pos1+offsets[i];
 
  423   assert(pos0 != pos1);
 
  426   assert(pos0 - pos1 == offsets[offset_id]);
 
  432   assert(abs(ret[0]) < plain_table_size);
 
  433   assert(abs(ret[1]) < plain_table_size + x_table_size);
 
  434   assert(abs(ret[2]) < plain_table_size + x_table_size + y_table_size);
 
  435   assert(ret[1] == 0 || abs(ret[1]) > plain_table_size);
 
  436   assert(ret[2] == 0 || abs(ret[2]) > plain_table_size + x_table_size);
 
  455     const Piece p = state.pieceOf(i);
 
  456     ret += pieceValueDouble(state, p, values);
 
  467   int ret = last_value;
 
  473     for (
size_t i=0; i<offsets.size(); ++i) {
 
  475       const Piece p = state.pieceAt(target);
 
  479       ret -= value(i, p, from, moved.
oldPtypeO(), values);      
 
  486     for (
size_t i=0; i<offsets.size(); ++i) {
 
  488       const Piece p = state.pieceAt(target);
 
  492       ret += value(i, p, to, moved.
ptypeO(), values);      
 
  498   for (
size_t i=0; i<offsets.size(); ++i) {
 
  500     const Piece p = state.pieceAt(target);
 
  504     ret += value(i, p, to, moved.
ptypeO(), values);      
 
  509   const Offset diff = to - from;
 
  520   assert(pos0 != pos1);
 
  522   assert(pos0 - pos1 == offsets[offset_id]);
 
  528 template <
int Direction, 
int Offset>
 
  543   const Piece* base_ptr= state.getPiecePtr(base);
 
  545     sum12One<4,18>(base_ptr,xbase,ybase)+
 
  546     + sum12One<3,17>(base_ptr,xbase,ybase)
 
  547     + sum12One<2,16>(base_ptr,xbase,ybase)
 
  548     + sum12One<1,15>(base_ptr,xbase,ybase)
 
  549     + sum12One<0,14>(base_ptr,xbase,ybase)
 
  550     + sum12One<5,1>(base_ptr,xbase,ybase)
 
  551     + sum12One<11,-1>(base_ptr,xbase,ybase)
 
  552     + sum12One<6,-14>(base_ptr,xbase,ybase)
 
  553     + sum12One<7,-15>(base_ptr,xbase,ybase)
 
  554     + sum12One<8,-16>(base_ptr,xbase,ybase)
 
  555     + sum12One<9,-17>(base_ptr,xbase,ybase)
 
  556     + sum12One<10,-18>(base_ptr,xbase,ybase);
 
  559 template<
int Direction, 
int Offset>
 
  579   const Piece* base_ptr= state.getPiecePtr(base);
 
  581     adjust12One<4,18>(base_ptr,xbase1,ybase1,xbase2,ybase2)
 
  582     + adjust12One<3,17>(base_ptr,xbase1,ybase1,xbase2,ybase2)
 
  583     + adjust12One<2,16>(base_ptr,xbase1,ybase1,xbase2,ybase2)
 
  584     + adjust12One<1,15>(base_ptr,xbase1,ybase1,xbase2,ybase2)
 
  585     + adjust12One<0,14>(base_ptr,xbase1,ybase1,xbase2,ybase2)
 
  586     + adjust12One<5,1>(base_ptr,xbase1,ybase1,xbase2,ybase2)
 
  587     + adjust12One<11,-1>(base_ptr,xbase1,ybase1,xbase2,ybase2)
 
  588     + adjust12One<6,-14>(base_ptr,xbase1,ybase1,xbase2,ybase2)
 
  589     + adjust12One<7,-15>(base_ptr,xbase1,ybase1,xbase2,ybase2)
 
  590     + adjust12One<8,-16>(base_ptr,xbase1,ybase1,xbase2,ybase2)
 
  591     + adjust12One<9,-17>(base_ptr,xbase1,ybase1,xbase2,ybase2)
 
  592     + adjust12One<10,-18>(base_ptr,xbase1,ybase1,xbase2,ybase2);
 
  598   int ret = last_value;
 
  604     ret+=sum12(state,to,moved.
ptypeO());
 
  608     ret-=sum12(state,from,moved.
oldPtypeO());
 
  611       ret+=sum12(state,to,moved.
ptypeO());
 
  612       const Offset diff = to-from;
 
  628       const Offset diff = to-from;
 
  656   for (
size_t i=0; i<offsets.size(); ++i) {
 
  658     const Piece q = state.pieceAt(target);
 
  663     int v = value(i, q, p, values);
 
  672   return pieceValueDouble(state, p, values)/2;