29   return (static_cast<const SimpleState&>(st1)
 
   39 template<osl::Player P>
 
   43 #ifdef ALLOW_KING_ABSENCE 
   44   if (kingSquare<P>().isPieceStand())
 
   47   king8infos[P]=King8Info::make<altP>(*
this,kingSquare<P>()).uint64Value();
 
   61   for(
int num=0;num<40;num++){
 
   80     makeKing8Info<BLACK>();
 
   81   if(kingSquare<WHITE>().isOnBoard())
 
   82     makeKing8Info<WHITE>();
 
   94   mask_t pieces = effect.selectBit<
PAWN>(), ppieces;
 
   97     ppieces = pieces & promoted.getMask<
PAWN>();
 
  103   pieces = effect.selectBit<
LANCE>();
 
  106     ppieces = pieces & promoted.getMask<
LANCE>();
 
  113   effect.clearBit<
KING>();
 
  117 #if OSL_WORDSIZE == 64 
  120   const int index = effect.getMask(0).any() ? 0 : 1;
 
  122   ppieces = effect.getMask(index) & promoted.getMask(index);
 
  123   pieces = effect.getMask(index) & ~ppieces;
 
  124   const int num = pieces.any() 
 
  125     ? (ppieces.any() ? 
std::min(pieces.bsf(),ppieces.bsf()) : pieces.bsf()) 
 
  127   return pieceOf(num + index*32);
 
  133   assert(! inCheck(P));
 
  134   PieceMask pieces = piecesOnBoard(P) & effectedMask(
alt(P));
 
  135   PieceMask nolance = pieces; nolance.clearBit<
LANCE>();
 
  136   int pp=-1, npp=-1, ret=-1;
 
  138   for (
int i=lance_index; i>=0; --i) {
 
  139     mask_t all = nolance.getMask(i);
 
  140     mask_t promoted = all & promotedPieces().getMask(i);
 
  141     mask_t notpromoted = all & ~promoted;
 
  142     if (promoted.any()) {
 
  143       pp = promoted.bsr() + i*32;
 
  146     if (notpromoted.any())
 
  147       npp = notpromoted.bsr() + i*32;
 
  154     mask_t plance = lance & promotedPieces().getMask(lance_index);
 
  156       return pieceOf(plance.bsr()+lance_index*32);
 
  157     return pieceOf(lance.bsr()+lance_index*32);
 
  171   const Square from = last_move.
from(), to = last_move.
to();
 
  176     return hasEffectAt(turn(), from);
 
  180                        kingSquare(
alt(turn())))
 
  182                                     kingSquare(
alt(turn())));
 
  183   const Piece piece = pieceOnBoard(to);
 
  184   if (! pin(
alt(turn())).test(piece.
number()))
 
  195   assert(turn() == move.
player());
 
  201   assert(isAlmostValidMove(move));
 
  206     doDropMove(to,move.
ptype());
 
  213       doCaptureMove(from,to,captured,move.
promoteMask());
 
  229   CArray<PieceMask,2> pin_or_open_backup;
 
  230   KingMobility king_mobility_backup;
 
  231   PieceMask promoted_backup;
 
  232   CArray<PieceMask,2> effected_mask_backup;
 
  233   CArray<PieceMask,2> effected_changed_mask_backup;
 
  234   CArray<uint64_t,2> king8infos_backup;
 
  237     prologueSimple(Player2Type<BLACK>(), from, to, promoteMask, 
 
  238                    oldPiece, num, oldPtypeO, newPtypeO, 
 
  239                    pin_or_open_backup, king_mobility_backup,
 
  240                    promoted_backup, effected_mask_backup, effected_changed_mask_backup,king8infos_backup,mobilityTable);
 
  243     prologueSimple(Player2Type<WHITE>(), from, to, promoteMask, 
 
  244                    oldPiece, num, oldPtypeO, newPtypeO, 
 
  245                    pin_or_open_backup, king_mobility_backup,
 
  246                    promoted_backup, effected_mask_backup, effected_changed_mask_backup,king8infos_backup,mobilityTable);
 
  249     clearPawn(turn(),from);
 
  256   int num0, num1, num1Index;
 
  258   CArray<PieceMask,2> pin_or_open_backup;
 
  259   KingMobility king_mobility_backup;
 
  260   PieceMask promoted_backup;
 
  261   CArray<PieceMask,2> effected_mask_backup;
 
  262   CArray<PieceMask,2> effected_changed_mask_backup;
 
  263   CArray<uint64_t,2> king8infos_backup;
 
  266     prologueCapture(Player2Type<BLACK>(), from, to, target, promoteMask, oldPiece, oldPtypeO, 
 
  267                     capturePtypeO, newPtypeO, num0, num1, num1Index,num1Mask, 
 
  268                     pin_or_open_backup, king_mobility_backup,
 
  269                     promoted_backup, effected_mask_backup, effected_changed_mask_backup,king8infos_backup,mobilityTable);
 
  272     prologueCapture(Player2Type<WHITE>(), from, to, target, promoteMask, oldPiece, oldPtypeO, 
 
  273                     capturePtypeO, newPtypeO, num0, num1, num1Index,num1Mask, 
 
  274                     pin_or_open_backup, king_mobility_backup,
 
  275                     promoted_backup, effected_mask_backup, effected_changed_mask_backup,king8infos_backup,mobilityTable);
 
  278   if (capturePtype==
PAWN)
 
  279     clearPawn(
alt(turn()),to);
 
  281     clearPawn(turn(),from);
 
  291   CArray<PieceMask,2> pin_or_open_backup;
 
  292   KingMobility king_mobility_backup;
 
  293   CArray<PieceMask,2> effected_mask_backup;
 
  294   CArray<PieceMask,2> effected_changed_mask_backup;
 
  295   CArray<uint64_t,2> king8infos_backup;
 
  298     prologueDrop(Player2Type<BLACK>(), to, ptype, oldPiece, num, ptypeO, numIndex, numMask, 
 
  299                  pin_or_open_backup, king_mobility_backup,
 
  300                  effected_mask_backup, effected_changed_mask_backup,king8infos_backup,mobilityTable);
 
  303     prologueDrop(Player2Type<WHITE>(), to, ptype, oldPiece, num, ptypeO, numIndex, numMask, 
 
  304                  pin_or_open_backup, king_mobility_backup,
 
  305                  effected_mask_backup, effected_changed_mask_backup,king8infos_backup,mobilityTable);
 
  311 template<osl::Player P>
 
  314                Piece& oldPiece, 
int& num, 
 
  316                CArray<PieceMask,2>& pin_or_open_backup,
 
  317                KingMobility& king_mobility_backup,
 
  318                PieceMask& promoted_backup,
 
  319                CArray<PieceMask,2>& effected_mask_backup,
 
  320                CArray<PieceMask,2>& effected_changed_mask_backup,
 
  321                CArray<uint64_t,2>& king8infos_backup,
 
  322                MobilityTable &mobility_backup)
 
  324   mobility_backup = effects.mobilityTable;
 
  325   pin_or_open_backup = pin_or_open;
 
  326   king_mobility_backup = king_mobility;
 
  327   effected_mask_backup = effects.effected_mask;
 
  328   effected_changed_mask_backup = effects.effected_changed_mask;
 
  329   king8infos_backup=king8infos;
 
  331   oldPiece=pieceAt(from);
 
  336   oldPtypeO=oldPiece.
ptypeO();
 
  337   new_ptypeo=newPiece.
ptypeO();
 
  339   setPieceOf(num,newPiece);
 
  340   effects.clearChangedEffects();
 
  341   effects.clearEffectedChanged();
 
  342   effects.template doEffect<NumBitmapEffect::Sub,true>(*
this,oldPtypeO,from,num);
 
  345   effects.effectedNumTable[num].clear();
 
  346   setBoard(to,newPiece);
 
  347   effects.template doBlockAt<NumBitmapEffect::Sub,true>(*
this,to,num);
 
  349   effects.template doBlockAt<NumBitmapEffect::Add,true>(*
this,from,num);
 
  350   effects.template doEffect<NumBitmapEffect::Add,true>(*
this,new_ptypeo,to,num);
 
  356     pin_or_open[P].reset(num);
 
  357     recalcPinOpen(from,lastD,P);
 
  358     recalcPinOpen(to,lastD,P);
 
  362     pin_or_open[
alt(P)].reset(num);
 
  363     recalcPinOpen(from,lastD,
alt(P));
 
  364     recalcPinOpen(to,lastD,
alt(P));
 
  366   promoted_backup = promoted;
 
  369   if(hasEffectAt(
BLACK,to))
 
  370     effects.effected_mask[
BLACK].set(num);
 
  372     effects.effected_mask[
BLACK].reset(num);
 
  373   if(hasEffectAt(
WHITE,to))
 
  374     effects.effected_mask[
WHITE].set(num);
 
  376     effects.effected_mask[
WHITE].reset(num);
 
  377   effects.effected_changed_mask[
BLACK].set(num);
 
  378   effects.effected_changed_mask[
WHITE].set(num);
 
  380     BoardMask changed=changedEffects(
BLACK)|changedEffects(
WHITE);
 
  384        || pin_or_open[
BLACK]!=pin_or_open_backup[
BLACK])
 
  385       makeKing8Info<BLACK>();
 
  387        || pin_or_open[
WHITE]!=pin_or_open_backup[
WHITE])
 
  388       makeKing8Info<WHITE>();
 
  395                const CArray<PieceMask,2>& pin_or_open_backup,
 
  396                const KingMobility& king_mobility_backup,
 
  397                const PieceMask& promoted_backup,
 
  398                const CArray<PieceMask,2>& effected_mask_backup,
 
  399                const CArray<PieceMask,2>& effected_changed_mask_backup,
 
  400                const CArray<uint64_t,2>& king8infos_backup,
 
  401                const MobilityTable & mobility_backup)
 
  403   setPieceOf(num,oldPiece);
 
  404   effects.doEffect<NumBitmapEffect::Sub,
false>(*
this,
newPtypeO,to,num);
 
  405   setBoard(from,oldPiece);
 
  406   effects.effectedNumTable[num].clear();
 
  407   effects.doBlockAt<NumBitmapEffect::Sub,
false>(*
this,from,num);
 
  409   effects.doBlockAt<NumBitmapEffect::Add,
false>(*
this,to,num);
 
  410   effects.doEffect<NumBitmapEffect::Add,
false>(*
this,oldPtypeO,from,num);
 
  411   effects.invalidateChangedEffects();
 
  412   pin_or_open = pin_or_open_backup;
 
  413   king_mobility = king_mobility_backup;
 
  414   promoted = promoted_backup;
 
  415   effects.effected_mask = effected_mask_backup;
 
  416   effects.effected_changed_mask = effected_changed_mask_backup;
 
  417   effects.mobilityTable = mobility_backup;
 
  418   king8infos = king8infos_backup;
 
  421 template<osl::Player P>
 
  425              int& numIndex, 
mask_t& numMask,
 
  426              CArray<PieceMask,2>& pin_or_open_backup,
 
  427              KingMobility& king_mobility_backup,
 
  428              CArray<PieceMask,2>& effected_mask_backup,
 
  429              CArray<PieceMask,2>& effected_changed_mask_backup,
 
  430              CArray<uint64_t,2>& king8infos_backup,
 
  431              MobilityTable &mobility_backup)
 
  433   king8infos_backup = king8infos;
 
  434   mobility_backup = effects.mobilityTable;
 
  435   pin_or_open_backup = pin_or_open;
 
  436   king_mobility_backup = king_mobility;
 
  437   effected_mask_backup = effects.effected_mask;
 
  438   effected_changed_mask_backup = effects.effected_changed_mask;
 
  439 #if OSL_WORDSIZE == 64 
  441 #elif OSL_WORDSIZE == 32 
  444   const mask_t ownMochigoma=
 
  446   assert(ownMochigoma.any());
 
  447   numMask=ownMochigoma.lowestBit();
 
  448   int numLow = ownMochigoma.bsf();
 
  449   num = numLow|(numIndex<<5);
 
  450   oldPiece=pieceOf(num);
 
  451   Piece newPiece=oldPiece;
 
  454   setPieceOf(num,newPiece);
 
  455   effects.clearChangedEffects();
 
  456   effects.clearEffectedChanged();
 
  457   effects.template doBlockAt<NumBitmapEffect::Sub,true>(*
this,to,num);
 
  458   effects.template doEffect<NumBitmapEffect::Add,true>(*
this,ptypeO,to,num);
 
  459   setBoard(to,newPiece);
 
  460   standMask(P).xorMask(numIndex,numMask);
 
  462   pieces_onboard[P].xorMask(numIndex,numMask);
 
  465     recalcPinOpen(to,lastD,P);
 
  469     recalcPinOpen(to,lastD,
alt(P));
 
  471   if(hasEffectAt(
BLACK,to))
 
  472     effects.effected_mask[
BLACK].set(num);
 
  474     effects.effected_mask[
BLACK].reset(num);
 
  475   if (hasEffectAt(
WHITE,to))
 
  476     effects.effected_mask[
WHITE].set(num);
 
  478     effects.effected_mask[
WHITE].reset(num);
 
  479   effects.effected_changed_mask[
BLACK].set(num);
 
  480   effects.effected_changed_mask[
WHITE].set(num);
 
  482     BoardMask changed=changedEffects(
BLACK)|changedEffects(
WHITE);
 
  485        || pin_or_open[
BLACK]!=pin_or_open_backup[
BLACK])
 
  486       makeKing8Info<BLACK>();
 
  488        || pin_or_open[
WHITE]!=pin_or_open_backup[
WHITE])
 
  489       makeKing8Info<WHITE>();
 
  493 template<osl::Player P>
 
  497              const CArray<PieceMask,2>& pin_or_open_backup,
 
  498              const KingMobility& king_mobility_backup,
 
  499              const CArray<PieceMask,2>& effected_mask_backup,
 
  500              const CArray<PieceMask,2>& effected_changed_mask_backup,
 
  501              const CArray<uint64_t,2>& king8infos_backup,
 
  502              const MobilityTable& mobility_backup)
 
  504   standMask(P).xorMask(numIndex,numMask);
 
  506   pieces_onboard[P].xorMask(numIndex,numMask);
 
  508   effects.template doEffect<NumBitmapEffect::Sub,false>(*
this,ptypeO,to,num);
 
  509   effects.template doBlockAt<NumBitmapEffect::Add,false>(*
this,to,num);
 
  510   setPieceOf(num,oldPiece);
 
  511   effects.effectedNumTable[num].clear();
 
  512   effects.invalidateChangedEffects();
 
  513   pin_or_open = pin_or_open_backup;
 
  514   king_mobility = king_mobility_backup;
 
  515   effects.effected_mask = effected_mask_backup;
 
  516   effects.effected_changed_mask = effected_changed_mask_backup;
 
  517   effects.mobilityTable = mobility_backup;
 
  518   king8infos = king8infos_backup;
 
  521 template<osl::Player P>
 
  526                 PtypeO& new_ptypeo, 
int& num0, 
int& num1, 
 
  527                 int& num1Index, 
mask_t& num1Mask,
 
  528                 CArray<PieceMask,2>& pin_or_open_backup,
 
  529                 KingMobility& king_mobility_backup,
 
  530                 PieceMask& promoted_backup,
 
  531                 CArray<PieceMask,2>& effected_mask_backup,
 
  532                 CArray<PieceMask,2>& effected_changed_mask_backup,
 
  533                 CArray<uint64_t,2>& king8infos_backup,
 
  534                 MobilityTable &mobility_backup)
 
  536   mobility_backup = effects.mobilityTable;
 
  537   pin_or_open_backup = pin_or_open;
 
  538   king_mobility_backup = king_mobility;
 
  539   effected_mask_backup = effects.effected_mask;
 
  540   effected_changed_mask_backup = effects.effected_changed_mask;
 
  541   king8infos_backup = king8infos;
 
  544   num1Index=PieceMask::numToIndex(num1);
 
  545   num1Mask=PieceMask::numToMask(num1);
 
  547   standMask(P).xorMask(num1Index,num1Mask);
 
  548   oldPiece=pieceAt(from);
 
  552   setPieceOf(num0,newPiece);
 
  555   oldPtypeO=oldPiece.
ptypeO();
 
  556   new_ptypeo=newPiece.
ptypeO();
 
  557   capturePtypeO=target.
ptypeO();
 
  559   effects.clearChangedEffects();
 
  560   effects.clearEffectedChanged();
 
  561   effects.setChangedPieces(effectSetAt(to));
 
  562   effects.template doEffect<NumBitmapEffect::Sub,true>(*
this,capturePtypeO,to,num1);
 
  563   effects.template doEffect<NumBitmapEffect::Sub,true>(*
this,oldPtypeO,from,num0);
 
  565   effects.template doBlockAt<NumBitmapEffect::Add,true>(*
this,from,num0);
 
  566   effects.effectedNumTable[num0]=effects.effectedNumTable[num1];
 
  567   effects.effectedNumTable[num1].clear();
 
  568   setBoard(to,newPiece);
 
  569   effects.template doEffect<NumBitmapEffect::Add,true>(*
this,new_ptypeo,to,num0);
 
  575     pin_or_open[P].reset(num0);
 
  576     pin_or_open[P].reset(num1); 
 
  577     recalcPinOpen(from,lastD,P);
 
  578     recalcPinOpen(to,lastD,P);
 
  582     pin_or_open[
alt(P)].reset(num0);
 
  583     pin_or_open[
alt(P)].reset(num1); 
 
  584     recalcPinOpen(from,lastD,
alt(P));
 
  585     recalcPinOpen(to,lastD,
alt(P));
 
  587   promoted_backup = promoted;
 
  588   promoted.reset(num1);
 
  589   effects.effected_mask[
BLACK].reset(num1);
 
  590   effects.effected_mask[
WHITE].reset(num1);
 
  593   if(hasEffectAt(
BLACK,to))
 
  594     effects.effected_mask[
BLACK].set(num0);
 
  596     effects.effected_mask[
BLACK].reset(num0);
 
  597   if(hasEffectAt(
WHITE,to))
 
  598     effects.effected_mask[
WHITE].set(num0);
 
  600     effects.effected_mask[
WHITE].reset(num0);
 
  601   effects.effected_changed_mask[
BLACK].set(num0);
 
  602   effects.effected_changed_mask[
WHITE].set(num0);
 
  604     BoardMask changed=changedEffects(
BLACK)|changedEffects(
WHITE);
 
  608        || pin_or_open[
BLACK]!=pin_or_open_backup[
BLACK])
 
  609       makeKing8Info<BLACK>();
 
  611        || pin_or_open[
WHITE]!=pin_or_open_backup[
WHITE])
 
  612       makeKing8Info<WHITE>();
 
  616 template<osl::Player P>
 
  621                 int num1Index, 
mask_t num1Mask,
 
  622                 const CArray<PieceMask,2>& pin_or_open_backup,
 
  623                 const KingMobility& king_mobility_backup,
 
  624                 const PieceMask& promoted_backup,
 
  625                 const CArray<PieceMask,2>& effected_mask_backup,
 
  626                 const CArray<PieceMask,2>& effected_changed_mask_backup,
 
  627                 const CArray<uint64_t,2>& king8infos_backup,
 
  628                 const MobilityTable &mobility_backup)
 
  630   standMask(P).xorMask(num1Index,num1Mask);
 
  633   effects.effectedNumTable[num1]=effects.effectedNumTable[num0];
 
  634   effects.effectedNumTable[num0].clear();
 
  635   setPieceOf(num0,oldPiece);
 
  636   setPieceOf(num1,target);
 
  637   effects.template doEffect<NumBitmapEffect::Sub,false>(*
this,
newPtypeO,to,num0);
 
  638   setBoard(from,oldPiece);
 
  640   effects.template doBlockAt<NumBitmapEffect::Sub,false>(*
this,from,num0);
 
  641   effects.template doEffect<NumBitmapEffect::Add,false>(*
this,capturePtypeO,to,num1);
 
  642   effects.template doEffect<NumBitmapEffect::Add,false>(*
this,oldPtypeO,from,num0);
 
  643   effects.invalidateChangedEffects();
 
  644   pin_or_open = pin_or_open_backup;
 
  645   king_mobility = king_mobility_backup;
 
  646   promoted = promoted_backup;
 
  647   effects.effected_mask = effected_mask_backup;
 
  648   effects.effected_changed_mask = effected_changed_mask_backup;
 
  649   effects.mobilityTable = mobility_backup;
 
  650   king8infos = king8infos_backup;
 
  660       std::cerr << 
"error before effect\n";
 
  664   if (!(effects1==effects))
 
  668       std::cerr << 
"Effect error 1" << std::endl;
 
  670       for(
int y=1;y<=9;y++)
 
  674           if (!(effects1.
effectSetAt(pos)==effects.effectSetAt(pos)))
 
  676             std::cerr << pos << 
",real=" << effects.effectSetAt(pos) << 
",ideal=" << effects1.
effectSetAt(pos) << std::endl;
 
  679       for(
int num=0;num<=39;num++){
 
  680         for(
int i=0;i<8;i++){
 
  683             std::cerr << 
"piece=" << pieceOf(num) << 
",num=" << num << 
",d=" << d << 
",v1=" << effects.effectedNumTable[num][d] << 
",v2=" << effects1.
effectedNumTable[num][d] << std::endl;
 
  687       std::cerr << effects.effectedNumTable << std::endl;
 
  691   for (
int z=0; z<2; ++z) {
 
  693 #ifdef ALLOW_KING_ABSENCE 
  694     if (kingSquare(p).isPieceStand())
 
  698     if (pin(p) != pin2) {
 
  700         std::cerr << 
"pin for " << p << 
" differs " << pin(p) << 
" " << pin2 << 
"\n";
 
  706         std::cerr << 
"king8info for " << p << 
" differs \n" << 
King8Info(Iking8Info(p)) << 
"\n" << king8info2 << 
"\n";
 
  711     const Piece p = pieceOf(i);
 
  715           std::cerr << 
"promoted differs " << p << 
" " << promoted << 
" " << promoted.test(i) << 
"\n";
 
  727   const CArray<BoardMask,2> changed_squares
 
  728     = {{ changedEffects(
BLACK), changedEffects(
WHITE) }};
 
  729   const BoardMask changed_all = changed_squares[
BLACK] | changed_squares[
WHITE];
 
  730   CArray<BoardMask, Piece::SIZE> each_effect, prev_effect;
 
  732     each_effect[i].clear();
 
  733     prev_effect[i].clear();
 
  735   for (
int x=1; x<=9; ++x) {
 
  736     for (
int y=1; y<=9; ++y) {
 
  739         if (effectSetAt(sq).test(i))
 
  740           each_effect[i].set(sq);
 
  742           prev_effect[i].set(sq);
 
  744       if (! changed_all.test(sq))
 
  749             std::cerr << 
"changedEffects unset\n" << *
this << moved << sq << 
"\n";        
 
  754       for (
int i=0; i<2; ++i) 
 
  757         if (! changed_squares[pl].test(sq))
 
  759           if ((effectSetAt(sq) & piecesOnBoard(pl))
 
  763               std::cerr << 
"changedEffects unset for " << pl << 
"\n" << *
this << moved << sq << 
"\n";
 
  772   const NumBitmapEffect changed_effect_pieces = changedPieces(); 
 
  774     if (each_effect[i] == prev_effect[i])
 
  776     if (! changed_effect_pieces.test(i)) {
 
  779         std::cerr << 
"changedPieces() unset\n" << *
this << moved << i 
 
  780                   << 
" " << each_effect[i] << 
" != " <<  prev_effect[i] << 
"\n";
 
  788     for (
int j=0; j<2; ++j) 
 
  793       if (prev.
effectedMask(pl).test(i) != effectedMask(pl).test(i)) {
 
  794         if (! effectedChanged(pl).test(i)) {
 
  797             std::cerr << 
"effectedChanged(" << pl << 
") unset\n" << *
this << moved << i 
 
  808 template <
bool show_error>
 
  810 #if (defined __GNUC__) && (! defined GPSONE) && (! defined GPSUSIONE) 
  816   assert(this->turn() == move.
player());
 
  817   assert(isValidMoveByRule(move, 
true));
 
  821     return isAlmostValidDrop<show_error>(move);
 
  823   const Piece from_piece = this->pieceAt(from);
 
  825   if (! testValidityOtherThanEffect<show_error>(move))
 
  827   if(!hasEffectByPiece(from_piece,to)){
 
  829       std::cerr << 
" No such move2 : " << move << std::endl;
 
  842     return isAlmostValidMove<true>(move);
 
  844     return isAlmostValidMove<false>(move);
 
  850   os<< static_cast<SimpleState const&>(*this);
 
  851   for(
int y=1;y<=9;y++){
 
  853     for(
int x=9;x>0;x--){
 
  861     if (standMask(
BLACK).test(num)){
 
  865     else if (standMask(
WHITE).test(num)){
 
  878   PieceMask mask=piecesOnBoard(
alt(defense));
 
  879   makePinOpenDir<UL>(
target,pins,mask,defense);
 
  880   makePinOpenDir<U>(
target,pins,mask,defense);
 
  881   makePinOpenDir<UR>(
target,pins,mask,defense);
 
  882   makePinOpenDir<L>(
target,pins,mask,defense);
 
  883   makePinOpenDir<R>(
target,pins,mask,defense);
 
  884   makePinOpenDir<DL>(
target,pins,mask,defense);
 
  885   makePinOpenDir<D>(
target,pins,mask,defense);
 
  886   makePinOpenDir<DR>(
target,pins,mask,defense);
 
  893   pin_or_open[defense]=makePinOpen(kingSquare(defense),defense);
 
  901     return allEffectAt<PAWN>(attack, 
target);
 
  903     return allEffectAt<LANCE>(attack, 
target);
 
  905     return allEffectAt<KNIGHT>(attack, 
target);
 
  907     return allEffectAt<SILVER>(attack, 
target);
 
  909     return allEffectAt<GOLD>(attack, 
target);
 
  911     return allEffectAt<BISHOP>(attack, 
target);
 
  913     return allEffectAt<ROOK>(attack, 
target);
 
  915     return allEffectAt<KING>(attack, 
target);
 
  928 #if defined(__i386__) || defined(__x86_64__) 
  940     *((
v2di*)&(*this).board[16])=b16;
 
  941     *((
v2di*)&(*this).board[20])=b20;
 
  942     *((
v2di*)&(*this).board[24])=b24;
 
  943     *((
v2di*)&(*this).board[32])=b32;
 
  944     *((
v2di*)&(*this).board[36])=b36;
 
  945     *((
v2di*)&(*this).board[40])=b40;
 
  946     *((
v2di*)&(*this).board[48])=b48;
 
  947     *((
v2di*)&(*this).board[52])=b52;
 
  948     *((
v2di*)&(*this).board[56])=b56;
 
  964     *((
v2di*)&(*this).board[64])=b64;
 
  965     *((
v2di*)&(*this).board[68])=b68;
 
  966     *((
v2di*)&(*this).board[72])=b72;
 
  968     *((
v2di*)&(*this).board[80])=b80;
 
  969     *((
v2di*)&(*this).board[84])=b84;
 
  970     *((
v2di*)&(*this).board[88])=b88;
 
  972     *((
v2di*)&(*this).board[96])=b96;
 
  973     *((
v2di*)&(*this).board[100])=b100;
 
  974     *((
v2di*)&(*this).board[104])=b104;
 
  988     *((
v2di*)&(*this).board[112])=b112;
 
  989     *((
v2di*)&(*this).board[116])=b116;
 
  990     *((
v2di*)&(*this).board[120])=b120;
 
  992     *((
v2di*)&(*this).board[128])=b128;
 
  993     *((
v2di*)&(*this).board[132])=b132;
 
  994     *((
v2di*)&(*this).board[136])=b136;
 
  996     *((
v2di*)&(*this).board[144])=b144;
 
  997     *((
v2di*)&(*this).board[148])=b148;
 
  998     *((
v2di*)&(*this).board[152])=b152;
 
 1010     *((
v2di*)&(*this).pieces[0])=p0;
 
 1011     *((
v2di*)&(*this).pieces[4])=p4;
 
 1012     *((
v2di*)&(*this).pieces[8])=p8;
 
 1013     *((
v2di*)&(*this).pieces[12])=p12;
 
 1014     *((
v2di*)&(*this).pieces[16])=p16;
 
 1015     *((
v2di*)&(*this).pieces[20])=p20;
 
 1016     *((
v2di*)&(*this).pieces[24])=p24;
 
 1017     *((
v2di*)&(*this).pieces[28])=p28;
 
 1018     *((
v2di*)&(*this).pieces[32])=p32;
 
 1019     *((
v2di*)&(*this).pieces[36])=p36;
 
 1022   for(
int x=1;x<=9;x++)
 
 1023     for(
int y=1;y<=9;y++)
 
 1025   (*this).pieces=src.
pieces;
 
 1030   effects.copyFrom(src.
effects);
 
 1047   template bool NumEffectState:: 
 
 1049   template bool NumEffectState:: 
 
 1051   template void NumEffectState::makeKing8Info<BLACK>();
 
 1052   template void NumEffectState::makeKing8Info<WHITE>();
 
 1058                  PieceMask&, CArray<PieceMask,2>&, CArray<PieceMask,2>&,
 
 1059                  CArray<uint64_t,2>&, MobilityTable&);
 
 1063                  PieceMask&, CArray<PieceMask,2>&, CArray<PieceMask,2>&,
 
 1064                  CArray<uint64_t,2>&, MobilityTable&);
 
 1069                   CArray<PieceMask,2>&, KingMobility&, PieceMask&,
 
 1070                   CArray<PieceMask,2>&, CArray<PieceMask,2>&,
 
 1071                   CArray<uint64_t,2>&, MobilityTable&);
 
 1075                   CArray<PieceMask,2>&, KingMobility&, PieceMask&,
 
 1076                   CArray<PieceMask,2>&, CArray<PieceMask,2>&,
 
 1077                   CArray<uint64_t,2>&, MobilityTable&);
 
 1081                int&, 
mask_t&, CArray<PieceMask,2>&, KingMobility&,
 
 1082                CArray<PieceMask,2>&, CArray<PieceMask,2>&,
 
 1083                CArray<uint64_t,2>&, MobilityTable&);
 
 1086                int&, 
mask_t&, CArray<PieceMask,2>&, KingMobility&,
 
 1087                CArray<PieceMask,2>&, CArray<PieceMask,2>&,
 
 1088                CArray<uint64_t,2>&, MobilityTable&);
 
 1092                   PtypeO, 
int, 
int, 
int, 
mask_t, 
const CArray<PieceMask,2>&,
 
 1093                   const KingMobility&, 
const PieceMask&, 
const CArray<PieceMask,2>&,
 
 1094                   const CArray<PieceMask,2>&, 
const CArray<uint64_t,2>&,
 
 1095                   const MobilityTable&);
 
 1098                   PtypeO, 
int, 
int, 
int, 
mask_t, 
const CArray<PieceMask,2>&,
 
 1099                   const KingMobility&, 
const PieceMask&, 
const CArray<PieceMask,2>&,
 
 1100                   const CArray<PieceMask,2>&, 
const CArray<uint64_t,2>&,
 
 1101                   const MobilityTable&);
 
 1104                const CArray<PieceMask,2>&, 
const KingMobility&, 
const CArray<PieceMask,2>&,
 
 1105                const CArray<PieceMask,2>&, 
const CArray<uint64_t,2>&, 
const MobilityTable&);
 
 1108                const CArray<PieceMask,2>&, 
const KingMobility&, 
const CArray<PieceMask,2>&,
 
 1109                const CArray<PieceMask,2>&, 
const CArray<uint64_t,2>&, 
const MobilityTable&);