{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
  {
  {
  {
  {
  {
  {
  {
  {
  {
  {
  {
  {
  {
  {
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
  }
 */
    
bool
    {
    {
    {
    {
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
  {  
#else
#if 0
osl::
osl::
      
  else
  else
  else
  else
  else
  else
  else
  else
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
      {
      {
      }
      }
      }
      }
      }
      }
      }
  else{
  else{
  else{
    else
  else {
  else {
  else {
        {
        {
        {
        }
        }
        }
        }
        }
        }
  default:
  int num;
bool osl::
          {
          }
          }
          }
    return;
    return;
    return;
    }      
// ;;; End:
  case GOLD:
  case KING:
  numIndex=0;
namespace osl
    assert(0);
  return pins;
  return true;
  return true;
  return true;
#ifdef MINIMAL
      continue;
      continue;
  changeTurn();
#ifndef MINIMAL
#ifndef MINIMAL
#ifndef MINIMAL
#ifndef MINIMAL
#ifndef MINIMAL
#ifndef MINIMAL
#ifndef MINIMAL
#ifndef MINIMAL
// ;;; mode:c++
    return true;
  PtypeO ptypeO;
  if (inCheck())
  if(show_error)
    return false;
    return false;
    return false;
    return false;
    return false;
    return false;
    return false;
    return false;
    return false;
    return false;
    return false;
    return false;
  Piece oldPiece;
  Piece oldPiece;
  Piece oldPiece;
  PieceMask pins;
  if (ret >= 0) {
  mask_t numMask;
  template Piece 
  template Piece 
      return true;
    if (showError)
    if (showError)
  if (inCheck()) {
  if (promoteMask)
  if (promoteMask)
  if (ptype==PAWN)
  mask_t num1Mask;
  return mask_t();
  switch (ptype) {
      return false;
      return false;
      return false;
    makeMovePass();
    makePinOpen(P);
    makePinOpen(P);
  return primDir(d)
  show_error=false;
#ifndef DFPNSTATONE
#include <iostream>
                 });
      if (showError)
      if (showError)
    changed.set(to);
    changed.set(to);
    changed.set(to);
    os << std::endl;
  if (effect.none())
  if (lance.any()) {
  if (pieces.any()) 
  if (pieces.any()) 
  if(turn()==BLACK){
  if(turn()==BLACK){
  int num, numIndex;
/* numEffectState.cc
typedef __v2di v2di;
        return false;
      if (show_error)
    if (pieces.any())
    if (pieces.any())
    if (plance.any())
    if (show_error) {
    os << 'P' << y;  
  if (! effect.any())
  if (turn()==BLACK){
  makePinOpen(BLACK);
  makePinOpen(WHITE);
         << std::endl;
         << std::endl;
        if (showError)
      Square pos(x,y);
    // 確認が必要
    changed.set(from);
    changed.set(from);
    promoted.set(num);
  const int index = 0;
  if (move.isPass()) {
  newPiece+=(to-from);
  newPiece+=(to-from);
  promoted.resetAll();
  setBoard(to,target);
#if OSL_WORDSIZE == 64
#include <emmintrin.h>
const osl::Piece osl::
const osl::Piece osl::
          return false;
          return false;
    Direction lastD=UL;
    Direction lastD=UL;
    Direction lastD=UL;
    Direction lastD=UL;
    Direction lastD=UL;
    Direction lastD=UL;
    if (p.isOnBoard()){
    pieces &= ~ppieces;
    pieces &= ~ppieces;
    promoted.set(num0);
    setPawn(turn(),to);
  // 持ち駒の表示
  assert(! inCheck(P));
  for(int x=1;x<=9;x++)
  generateLegal(moves);
  num1=target.number();
  promoted.reset(num1);
// ;;; Local Variables:
// ;;; c-basic-offset:2
template<osl::Player P>
template<osl::Player P>
template<osl::Player P>
template<osl::Player P>
template<osl::Player P>
template<osl::Player P>
    if (p.isOnBoard()) {
    return pieceOf(num);
    return pieceOf(ret);
  // test changedEffects
  case PAWN: case PPAWN:
  case ROOK: case PROOK:
  for(int y=1;y<=9;y++){
  num=oldPiece.number();
  oldPiece=pieceOf(num);
  return Piece::EMPTY();
  setBoard(to,newPiece);
  setBoard(to,newPiece);
  setBoard(to,newPiece);
#elif OSL_WORDSIZE == 32
            return false;
          if (show_error)
          if (show_error)
      if (p.isPromoted())
      std::cerr << *this;
    MoveVector all_moves;
    Piece p=pieceOf(num);
    for(int x=9;x>0;x--){
    for(int y=1;y<=9;y++)
    if (pin(p) != pin2) {
    if (promoted.any()) {
  // test changedPieces()
  assert(move.isValid());
  if (capturePtype==PAWN)
  num0=oldPiece.number();
  oldPiece=pieceAt(from);
  oldPiece=pieceAt(from);
#ifdef ALLOW_KING_ABSENCE
#ifdef ALLOW_KING_ABSENCE
          Square pos(x,y);
        promoted.set(num);
    if (notpromoted.any())
    return Piece::EMPTY();
  Piece newPiece=oldPiece;
  assert(move.isNormal());
  case LANCE: case PLANCE:
  effect.clearBit<KING>();
  if (from.isPieceStand())
  setBoard(from,oldPiece);
  setBoard(from,oldPiece);
  setPieceOf(num1,target);
bool osl::NumEffectState::
template <bool show_error>
void osl::NumEffectState::
void osl::NumEffectState::
void osl::NumEffectState::
void osl::NumEffectState::
void osl::NumEffectState::
void osl::NumEffectState::
void osl::NumEffectState::
void osl::NumEffectState::
void osl::NumEffectState::
void osl::NumEffectState::
void osl::NumEffectState::
            if (show_error)
      for(int i=0;i<2;i++){
      for(int y=1;y<=9;y++)
    clearPawn(turn(),from);
    clearPawn(turn(),from);
    each_effect[i].clear();
    makeKing8Info<BLACK>();
    makeKing8Info<WHITE>();
    prev_effect[i].clear();
  const Player altP=alt(P);
  for (int z=0; z<2; ++z) {
  if (!(effects1==effects))
  if(hasEffectAt(BLACK,to))
  if(hasEffectAt(BLACK,to))
  if(hasEffectAt(BLACK,to))
  if(hasEffectAt(WHITE,to))
  if(hasEffectAt(WHITE,to))
  ptypeO=newPiece.ptypeO();
  setPieceOf(num,newPiece);
  setPieceOf(num,newPiece);
  setPieceOf(num,oldPiece);
  setPieceOf(num,oldPiece);
        for(int x=9;x>0;x--)
      const Square sq(x, y);
      return pieceOf(ret);  
    for (int j=0; j<2; ++j) 
    ret = std::max(pp, npp);
  (*this).pieces=src.pieces;
  PieceMask promoted_backup;
  PieceMask promoted_backup;
  case BISHOP: case PBISHOP:
  case KNIGHT: case PKNIGHT:
  case SILVER: case PSILVER:
  const Square to=move.to();
  const Square to=move.to();
  const mask_t ownMochigoma=
  for (int x=1; x<=9; ++x) {
  if (hasEffectAt(WHITE,to))
  if (last_move.isCapture())
  int num0, num1, num1Index;
  int pp=-1, npp=-1, ret=-1;
  setPieceOf(num0,newPiece);
  setPieceOf(num0,oldPiece);
                 [&](Move m){
        for(int i=0;i<8;i++){
      makeKing8Info<BLACK>();
      makeKing8Info<BLACK>();
      makeKing8Info<BLACK>();
      makeKing8Info<WHITE>();
      makeKing8Info<WHITE>();
      makeKing8Info<WHITE>();
    if (last_move.isCapture()
  assert(ownMochigoma.any());
  if (! last_move.isNormal())
  num = numLow|(numIndex<<5);
  promoted = promoted_backup;
  promoted = promoted_backup;
  promoted_backup = promoted;
  promoted_backup = promoted;
      for (int i=0; i<2; ++i) 
    clearPawn(alt(turn()),to);
    for (int y=1; y<=9; ++y) {
    pin_or_open[P].reset(num);
    recalcPinOpen(to,lastD,P);
    recalcPinOpen(to,lastD,P);
    recalcPinOpen(to,lastD,P);
  PtypeO oldPtypeO, newPtypeO;
  for(int num=0;num<40;num++){
  oldPtypeO=oldPiece.ptypeO();
  oldPtypeO=oldPiece.ptypeO();
  setBoard(to,Piece::EMPTY());
  setBoard(to,Piece::EMPTY());
#include "osl/simpleState.tcc"
    const Move move = moves[i];
    const Piece p = pieceOf(i);
    pin_or_open[P].reset(num0);
  : SimpleState(st),effects(st)
  king8infos_backup=king8infos;
  newPiece+=to-Square::STAND();
  new_ptypeo=newPiece.ptypeO();
  new_ptypeo=newPiece.ptypeO();
  pieces_onboard[0].resetAll();
  pieces_onboard[1].resetAll();
#include "osl/numEffectState.h"
__attribute__ ((used,noinline))
                int promoteMask,
    doDropMove(to,move.ptype());
    recalcPinOpen(from,lastD,P);
    recalcPinOpen(from,lastD,P);
  (*this).pawnMask=src.pawnMask;
  (*this).promoted=src.promoted;
  capturePtypeO=target.ptypeO();
  const Square from=move.from();
  const Square from=move.from();
  copyFrom(NumEffectState(src));
  effects.clearChangedEffects();
  effects.clearChangedEffects();
  effects.clearChangedEffects();
  effects.copyFrom(src.effects);
  move_action::Store store(out);
  setBoard(from,Piece::EMPTY());
  setBoard(from,Piece::EMPTY());
  template void NumEffectState::
  template void NumEffectState::
  template void NumEffectState::
  template void NumEffectState::
  template void NumEffectState::
  template void NumEffectState::
  template void NumEffectState::
  template void NumEffectState::
  template void NumEffectState::
  template void NumEffectState::
makePinOpen(osl::Player defense)
          each_effect[i].set(sq);
          prev_effect[i].set(sq);
      if (! changed_all.test(sq))
      pp = promoted.bsr() + i*32;
  assert(st1.isConsistent(true));
  assert(st2.isConsistent(true));
  effects.clearEffectedChanged();
  effects.clearEffectedChanged();
  effects.clearEffectedChanged();
  king8infos = king8infos_backup;
  king8infos = king8infos_backup;
  king8infos = king8infos_backup;
  king8infos_backup = king8infos;
  king8infos_backup = king8infos;
  template bool NumEffectState:: 
  template bool NumEffectState:: 
#include "osl/numEffectState.tcc"
doDropMove(Square to,Ptype ptype)
  (*this).used_mask=src.used_mask;
  assert(isAlmostValidMove(move));
  assert(turn() == move.player());
  forEachEffect(P, target, store);
  if (last_move.ptype() == KING) {
  int numLow = ownMochigoma.bsf();
  using namespace move_classifier;
  using namespace move_classifier;
  using namespace move_classifier;
  using namespace move_classifier;
  using namespace move_classifier;
NumEffectState::~NumEffectState() 
        Player pl=indexToPlayer(i);
      for(int num=0;num<=39;num++){
    if (captured != Piece::EMPTY())
    if (move.hasIgnoredUnpromote())
    pin_or_open[alt(P)].reset(num);
    recalcPinOpen(to,lastD,alt(P));
    recalcPinOpen(to,lastD,alt(P));
    recalcPinOpen(to,lastD,alt(P));
  // 自分自身の効きを外す
  numMask=ownMochigoma.lowestBit();
  pin_or_open = pin_or_open_backup;
  pin_or_open = pin_or_open_backup;
  pin_or_open = pin_or_open_backup;
  pin_or_open_backup = pin_or_open;
  pin_or_open_backup = pin_or_open;
  pin_or_open_backup = pin_or_open;
        if (effectSetAt(sq).test(i))
    *((v2di*)&(*this).pieces[0])=p0;
    *((v2di*)&(*this).pieces[4])=p4;
    *((v2di*)&(*this).pieces[8])=p8;
    if (standMask(BLACK).test(num)){
    mask_t all = nolance.getMask(i);
    pin_or_open[alt(P)].reset(num0);
  (*this).king8infos=src.king8infos;
  (*this).stand_mask=src.stand_mask;
  // explicit template instantiation
  // test effectedChanged(Player pl)
  KingMobility king_mobility_backup;
  KingMobility king_mobility_backup;
  KingMobility king_mobility_backup;
  for (int i=0; i<Piece::SIZE; ++i) 
osl::PieceMask osl::NumEffectState::
      npp = notpromoted.bsr() + i*32;
    *((v2di*)&(*this).board[16])=b16;
    *((v2di*)&(*this).board[20])=b20;
    *((v2di*)&(*this).board[24])=b24;
    *((v2di*)&(*this).board[32])=b32;
    *((v2di*)&(*this).board[36])=b36;
    *((v2di*)&(*this).board[40])=b40;
    *((v2di*)&(*this).board[48])=b48;
    *((v2di*)&(*this).board[52])=b52;
    *((v2di*)&(*this).board[56])=b56;
    *((v2di*)&(*this).board[64])=b64;
    *((v2di*)&(*this).board[68])=b68;
    *((v2di*)&(*this).board[72])=b72;
    *((v2di*)&(*this).board[80])=b80;
    *((v2di*)&(*this).board[84])=b84;
    *((v2di*)&(*this).board[88])=b88;
    *((v2di*)&(*this).board[96])=b96;
    if (kingSquare(p).isPieceStand())
    recalcPinOpen(from,lastD,alt(P));
    recalcPinOpen(from,lastD,alt(P));
    return hasEffectAt(turn(), from);
    v2di p0=*((v2di*)&src.pieces[0]);
    v2di p4=*((v2di*)&src.pieces[4]);
    v2di p8=*((v2di*)&src.pieces[8]);
  const Direction d=pinnedDir(piece);
  effects.invalidateChangedEffects();
  effects.invalidateChangedEffects();
  effects.invalidateChangedEffects();
  for (int i=0; i<Piece::SIZE; ++i) {
  for (int i=0; i<Piece::SIZE; ++i) {
  for (int i=0; i<Piece::SIZE; ++i) {
  if (!(st1.effects == st2.effects)) 
  if (kingSquare<P>().isPieceStand())
  if (oldPtypeO == newPtypeO(P,KING))
  if (oldPtypeO == newPtypeO(P,KING))
  if(kingSquare<BLACK>().isOnBoard())
  if(kingSquare<WHITE>().isOnBoard())
  pieces = effect.selectBit<LANCE>();
  return King8Info(Iking8Info(king));
  setPieceOf(num1,target.captured());
const osl::checkmate::King8Info osl::
        if(hasEffectAt(pl,p.square()))
    *((v2di*)&(*this).pieces[12])=p12;
    *((v2di*)&(*this).pieces[16])=p16;
    *((v2di*)&(*this).pieces[20])=p20;
    *((v2di*)&(*this).pieces[24])=p24;
    *((v2di*)&(*this).pieces[28])=p28;
    *((v2di*)&(*this).pieces[32])=p32;
    *((v2di*)&(*this).pieces[36])=p36;
    const Player p = indexToPlayer(z);
    v2di b16=*((v2di*)&src.board[16]);
    v2di b20=*((v2di*)&src.board[20]);
    v2di b24=*((v2di*)&src.board[24]);
    v2di b32=*((v2di*)&src.board[32]);
    v2di b36=*((v2di*)&src.board[36]);
    v2di b40=*((v2di*)&src.board[40]);
    v2di b48=*((v2di*)&src.board[48]);
    v2di b52=*((v2di*)&src.board[52]);
    v2di b56=*((v2di*)&src.board[56]);
    v2di b64=*((v2di*)&src.board[64]);
    v2di b68=*((v2di*)&src.board[68]);
    v2di b72=*((v2di*)&src.board[72]);
    v2di b80=*((v2di*)&src.board[80]);
    v2di b84=*((v2di*)&src.board[84]);
    v2di b88=*((v2di*)&src.board[88]);
    v2di b96=*((v2di*)&src.board[96]);
  (*this).pin_or_open=src.pin_or_open;
  effects.effected_mask[0].resetAll();
  effects.effected_mask[1].resetAll();
  for (int i=lance_index; i>=0; --i) {
  if (pieces.none() || ppieces.none())
  num1Mask=PieceMask::numToMask(num1);
  return pieceOf(std::min(num, nump));
  this->stand_count = src.stand_count;
    *((v2di*)&(*this).board[100])=b100;
    *((v2di*)&(*this).board[104])=b104;
    *((v2di*)&(*this).board[112])=b112;
    *((v2di*)&(*this).board[116])=b116;
    *((v2di*)&(*this).board[120])=b120;
    *((v2di*)&(*this).board[128])=b128;
    *((v2di*)&(*this).board[132])=b132;
    *((v2di*)&(*this).board[136])=b136;
    *((v2di*)&(*this).board[144])=b144;
    *((v2di*)&(*this).board[148])=b148;
    *((v2di*)&(*this).board[152])=b152;
    v2di p12=*((v2di*)&src.pieces[12]);
    v2di p16=*((v2di*)&src.pieces[16]);
    v2di p20=*((v2di*)&src.pieces[20]);
    v2di p24=*((v2di*)&src.pieces[24]);
    v2di p28=*((v2di*)&src.pieces[28]);
    v2di p32=*((v2di*)&src.pieces[32]);
    v2di p36=*((v2di*)&src.pieces[36]);
  CArray<uint64_t,2> king8infos_backup;
  CArray<uint64_t,2> king8infos_backup;
  CArray<uint64_t,2> king8infos_backup;
  const Piece piece = pieceOnBoard(to);
  for(int num=0;num<Piece::SIZE;num++){
  if (!(st1.promoted == st2.promoted)) 
  if (from.isPieceStand()) // 打つ手
  if(!hasEffectByPiece(from_piece,to)){
  king_mobility = king_mobility_backup;
  king_mobility = king_mobility_backup;
  king_mobility = king_mobility_backup;
  king_mobility_backup = king_mobility;
  king_mobility_backup = king_mobility;
  king_mobility_backup = king_mobility;
  numIndex=Ptype_Table.getIndex(ptype);
#include "osl/bits/numSimpleEffect.tcc"
#include "osl/move_classifier/check_.h"
#include "osl/move_generator/escape_.h"
const osl::mask_t osl::NumEffectState::
                  const MobilityTable&);
                  const MobilityTable&);
      moves.push_back(move.unpromote());
    v2di b100=*((v2di*)&src.board[100]);
    v2di b104=*((v2di*)&src.board[104]);
    v2di b112=*((v2di*)&src.board[112]);
    v2di b116=*((v2di*)&src.board[116]);
    v2di b120=*((v2di*)&src.board[120]);
    v2di b128=*((v2di*)&src.board[128]);
    v2di b132=*((v2di*)&src.board[132]);
    v2di b136=*((v2di*)&src.board[136]);
    v2di b144=*((v2di*)&src.board[144]);
    v2di b148=*((v2di*)&src.board[148]);
    v2di b152=*((v2di*)&src.board[152]);
  assert(isValidMoveByRule(move, true));
  assert(this->turn() == move.player());
  effect_action::StorePiece store(&out);
  effects.effectedNumTable[num].clear();
  effects.effectedNumTable[num].clear();
  effects.effectedNumTable[num].clear();
  if(target.isPieceStand()) return pins;
  mobility::MobilityTable mobilityTable;
  mobility::MobilityTable mobilityTable;
  mobility::MobilityTable mobilityTable;
  num1Index=PieceMask::numToIndex(num1);
#include "osl/move_generator/allMoves.h"
        if (prev.effectSetAt(sq).test(i))
      const Player pl = indexToPlayer(j);
      for (int i=0; i<Piece::SIZE; ++i) {
      pieces_onboard[p.owner()].set(num);
    else if (standMask(WHITE).test(num)){
    if (each_effect[i] == prev_effect[i])
    mask_t notpromoted = all & ~promoted;
    return isAlmostValidMove<true>(move);
  CArray<PieceMask,2> pin_or_open_backup;
  CArray<PieceMask,2> pin_or_open_backup;
  CArray<PieceMask,2> pin_or_open_backup;
  effects.effectedNumTable[num0].clear();
  effects.effectedNumTable[num1].clear();
  mask_t king = effect.selectBit<KING>();
  standMask(P).xorMask(numIndex,numMask);
  standMask(P).xorMask(numIndex,numMask);
#include "osl/move_classifier/safeMove.h"
void osl::NumEffectState::makeKing8Info()
               Piece& oldPiece, int& num, 
               PieceMask& promoted_backup,
    effects.effected_mask[BLACK].set(num);
    effects.effected_mask[BLACK].set(num);
    effects.effected_mask[WHITE].set(num);
    effects.effected_mask[WHITE].set(num);
    if (! changed_effect_pieces.test(i)) {
    return isAlmostValidMove<false>(move);
  (*this).king_mobility=src.king_mobility;
  const Ptype capturePtype=target.ptype();
  effects.mobilityTable = mobility_backup;
  effects.mobilityTable = mobility_backup;
  effects.mobilityTable = mobility_backup;
  mobility_backup = effects.mobilityTable;
  mobility_backup = effects.mobilityTable;
  mobility_backup = effects.mobilityTable;
  stand_count[P][ptype-PTYPE_BASIC_MIN]++;
  stand_count[P][ptype-PTYPE_BASIC_MIN]--;
  this->pieces_onboard=src.pieces_onboard;
  this->player_to_move=src.player_to_move;
                PieceMask& promoted_backup,
        const Player pl = indexToPlayer(i);
        if (! changed_squares[pl].test(sq))
      std::cerr << "error before effect\n";
    effects.effected_mask[BLACK].set(num0);
    effects.effected_mask[WHITE].set(num0);
  CArray<PieceMask,2> effected_mask_backup;
  CArray<PieceMask,2> effected_mask_backup;
  CArray<PieceMask,2> effected_mask_backup;
  const CArray<BoardMask,2> changed_squares
  effects.effected_mask[BLACK].reset(num1);
  effects.effected_mask[WHITE].reset(num1);
  if (!(st1.king8infos == st2.king8infos)) 
  mask_t lance = pieces.selectBit<LANCE>();
  standMask(P).xorMask(num1Index,num1Mask);
  standMask(P).xorMask(num1Index,num1Mask);
#include "osl/move_generator/move_action.h"
             MobilityTable &mobility_backup)
             int& numIndex, mask_t& numMask,
          effects.effected_mask[i].set(num);
        continue;                // captured
        if (! effectedChanged(pl).test(i)) {
    const Piece captured = pieceOnBoard(to);
    effects.effected_mask[BLACK].reset(num);
    effects.effected_mask[BLACK].reset(num);
    effects.effected_mask[WHITE].reset(num);
    effects.effected_mask[WHITE].reset(num);
  // あるいは自分自身のブロック
  effects.setChangedPieces(effectSetAt(to));
  pieces = effect.getMask(index) & ~ppieces;
#include "osl/move_classifier/moveAdaptor.h"
NumEffectState::king8Info(Player king) const
    effects.effected_mask[BLACK].reset(num0);
    effects.effected_mask[WHITE].reset(num0);
    if (ret >= PtypeTraits<KNIGHT>::indexMin)
    return allEffectAt<GOLD>(attack, target);
    return allEffectAt<KING>(attack, target);
    return allEffectAt<PAWN>(attack, target);
    return allEffectAt<ROOK>(attack, target);
  PieceMask mask=piecesOnBoard(alt(defense));
  PtypeO oldPtypeO, capturePtypeO, newPtypeO;
  if (!(st1.pin_or_open == st2.pin_or_open)) 
  if (!SimpleState::isConsistent(showError)) 
#include "osl/move_generator/effect_action.h"
void osl::NumEffectState::makeMove(Move move)
               MobilityTable &mobility_backup)
      && !Board_Table.isBetweenSafe(from, to, 
    return allEffectAt<LANCE>(attack, target);
  effects.effected_changed_mask[0].resetAll();
  effects.effected_changed_mask[1].resetAll();
  if (! pin(alt(turn())).test(piece.number()))
  makePinOpenDir<D>(target,pins,mask,defense);
  makePinOpenDir<L>(target,pins,mask,defense);
  makePinOpenDir<R>(target,pins,mask,defense);
  makePinOpenDir<U>(target,pins,mask,defense);
  os<< static_cast<SimpleState const&>(*this);
  pieces_onboard[P].xorMask(numIndex,numMask);
  pieces_onboard[P].xorMask(numIndex,numMask);
  return (static_cast<const SimpleState&>(st1)
                       kingSquare(alt(turn())))
                MobilityTable &mobility_backup)
                int num1Index, mask_t num1Mask,
      doSimpleMove(from,to,move.promoteMask());
      if (promoted.test(i) != p.isPromoted()) {
    GenerateEscapeKing::generate(*this, moves);
    return allEffectAt<BISHOP>(attack, target);
    return allEffectAt<KNIGHT>(attack, target);
    return allEffectAt<SILVER>(attack, target);
    return isAlmostValidDrop<show_error>(move);
    return pieceOf(lance.bsr()+lance_index*32);
  const Piece from_piece = this->pieceAt(from);
  effect::NumSimpleEffectTable effects1(*this);
  effected_mask_backup = effects.effected_mask;
  effected_mask_backup = effects.effected_mask;
  effected_mask_backup = effects.effected_mask;
  effects.effected_mask = effected_mask_backup;
  effects.effected_mask = effected_mask_backup;
  effects.effected_mask = effected_mask_backup;
  makePinOpenDir<DL>(target,pins,mask,defense);
  makePinOpenDir<DR>(target,pins,mask,defense);
  makePinOpenDir<UL>(target,pins,mask,defense);
  makePinOpenDir<UR>(target,pins,mask,defense);
bool osl::operator==(const NumEffectState& st1,
               const PieceMask& promoted_backup,
             KingMobility& king_mobility_backup,
          Direction d=static_cast<Direction>(i);
    assert(Piece_Table.getPtypeOf(ret) == PAWN);
    ppieces = pieces & promoted.getMask<PAWN>();
  effects.effected_changed_mask[BLACK].set(num);
  effects.effected_changed_mask[BLACK].set(num);
  effects.effected_changed_mask[WHITE].set(num);
  effects.effected_changed_mask[WHITE].set(num);
                const PieceMask& promoted_backup,
                int& num1Index, mask_t& num1Mask,
      if (prev.pieceOf(i).square() == moved.to())
      std::cerr << "Effect error 1" << std::endl;
    // そうでなければ全ての手を生成
    ppieces = pieces & promoted.getMask<LANCE>();
  effects.effected_changed_mask[BLACK].set(num0);
  effects.effected_changed_mask[WHITE].set(num0);
  for (int i=0, iend=moves.size(); i<iend; ++i) {
  if (!(st1.king_mobility == st2.king_mobility)) 
               KingMobility& king_mobility_backup,
             const MobilityTable& mobility_backup)
      return pieceOf(plance.bsr()+lance_index*32);
#include "osl/move_classifier/pawnDropCheckmate.h"
bool osl::NumEffectState::isCheck(Move move) const
                KingMobility& king_mobility_backup,
             CArray<uint64_t,2>& king8infos_backup,
          == static_cast<const SimpleState&>(st2));
          if ((effectSetAt(sq) & piecesOnBoard(pl))
  CArray<PieceMask,2> effected_changed_mask_backup;
  CArray<PieceMask,2> effected_changed_mask_backup;
  CArray<PieceMask,2> effected_changed_mask_backup;
  if (!(st1.pieces_onboard == st2.pieces_onboard)) 
NumEffectState::findThreatenedPiece(Player P) const
isAlmostValidMove(Move move,bool show_error) const{
makePinOpen(osl::Square target,osl::Player defense)
               CArray<uint64_t,2>&, MobilityTable&);
               CArray<uint64_t,2>&, MobilityTable&);
          effects.effected_changed_mask[i].set(num);
  mask_t pieces = effect.selectBit<PAWN>(), ppieces;
prologueDrop(Player2Type<P>, Square to, Ptype ptype,
                const MobilityTable &mobility_backup)
               CArray<uint64_t,2>& king8infos_backup,
               PtypeO& oldPtypeO, PtypeO& new_ptypeo,
               const MobilityTable & mobility_backup)
             CArray<PieceMask,2>& pin_or_open_backup,
    return hasEffectIf(last_move.capturePtypeO(), to,
  const int num = pieces.bsf(), nump = ppieces.bsf();
  hasEffectByWithRemove<BLACK>(Square, Square) const;
  hasEffectByWithRemove<WHITE>(Square, Square) const;
  pieces_onboard[alt(P)].xorMask(num1Index,num1Mask);
  pieces_onboard[alt(P)].xorMask(num1Index,num1Mask);
NumEffectState::wasCheckEvasion(Move last_move) const
bool osl::NumEffectState::isSafeMove(Move move) const
doSimpleMove(Square from, Square to, int promoteMask)
                            const NumEffectState& st2)
                 CArray<uint64_t,2>&, MobilityTable&);
                 CArray<uint64_t,2>&, MobilityTable&);
                CArray<uint64_t,2>& king8infos_backup,
                PtypeO newPtypeO, int num0, int num1, 
             const KingMobility& king_mobility_backup,
        if (effectSetAt(sq) != prev.effectSetAt(sq)) {
    pin_or_open[P].reset(num1); // captured is not pin
  if (! testValidityOtherThanEffect<show_error>(move))
NumEffectState::NumEffectState(const SimpleState& st) 
bool osl::NumEffectState::isOpenCheck(Move move) const
                  CArray<uint64_t,2>&, MobilityTable&);
                  CArray<uint64_t,2>&, MobilityTable&);
               CArray<PieceMask,2>& pin_or_open_backup,
             CArray<PieceMask,2>& effected_mask_backup,
  Piece newPiece=oldPiece.promoteWithMask(promoteMask);
  Piece newPiece=oldPiece.promoteWithMask(promoteMask);
  template void NumEffectState::makeKing8Info<BLACK>();
  template void NumEffectState::makeKing8Info<WHITE>();
epilogueSimple(Square from, Square to, Piece oldPiece, 
                   oldPiece, num, oldPtypeO, newPtypeO, 
                   oldPiece, num, oldPtypeO, newPtypeO, 
                CArray<PieceMask,2>& pin_or_open_backup,
               const KingMobility& king_mobility_backup,
             Piece& oldPiece, int& num, PtypeO& ptypeO, 
       || pin_or_open[BLACK]!=pin_or_open_backup[BLACK])
       || pin_or_open[BLACK]!=pin_or_open_backup[BLACK])
       || pin_or_open[BLACK]!=pin_or_open_backup[BLACK])
       || pin_or_open[WHITE]!=pin_or_open_backup[WHITE])
       || pin_or_open[WHITE]!=pin_or_open_backup[WHITE])
       || pin_or_open[WHITE]!=pin_or_open_backup[WHITE])
      os << csa::show(pieceAt(pos)) << effectSetAt(pos);
    mask_t promoted = all & promotedPieces().getMask(i);
  PieceMask nolance = pieces; nolance.clearBit<LANCE>();
NumEffectState::selectCheapPiece(PieceMask effect) const
bool osl::NumEffectState::isDirectCheck(Move move) const
osl::NumEffectState::isAlmostValidMove(Move move) const{
                const KingMobility& king_mobility_backup,
               CArray<PieceMask,2>& effected_mask_backup,
             const CArray<uint64_t,2>& king8infos_backup,
      doCaptureMove(from,to,captured,move.promoteMask());
      std::cerr << effects.effectedNumTable << std::endl;
    = {{ changedEffects(BLACK), changedEffects(WHITE) }};
    GenerateAllMoves::generate(turn(), *this, all_moves);
  return PlayerMoveAdaptor<Check>::isMember(*this, move);
                 pin_or_open_backup, king_mobility_backup,
                 pin_or_open_backup, king_mobility_backup,
                CArray<PieceMask,2>& effected_mask_backup,
                PtypeO& new_ptypeo, int& num0, int& num1, 
               CArray<PieceMask,2>&, CArray<PieceMask,2>&,
               CArray<PieceMask,2>&, CArray<PieceMask,2>&,
    King8Info king8info2 = King8Info::make(alt(p), *this);
  CArray<BoardMask, Piece::SIZE> each_effect, prev_effect;
void osl::NumEffectState::copyFrom(const SimpleState& src)
               const CArray<uint64_t,2>& king8infos_backup,
               int num, PtypeO oldPtypeO, PtypeO newPtypeO,
             const CArray<PieceMask,2>& pin_or_open_backup,
    pin_or_open[alt(P)].reset(num1); // captured is not pin
  if (last_move.isDrop() || last_move.oldPtype() == KNIGHT)
  if (promoteMask!=0 && num0<PtypeTraits<PAWN>::indexLimit)
  return ConditionAdaptor<SafeMove>::isMember(*this, move);
findEffect(Player P, Square target, PieceVector& out) const
                   pin_or_open_backup, king_mobility_backup,
                   pin_or_open_backup, king_mobility_backup,
                const CArray<uint64_t,2>& king8infos_backup,
        && hasEffectIf(last_move.capturePtypeO(), to, from))
      os << "P+00" << csa::show(Piece_Table.getPtypeOf(num))
      os << "P-00" << csa::show(Piece_Table.getPtypeOf(num))
      std::cerr << " No such move2 : " << move << std::endl;
    const PieceMask pin2 = effect_util::Pin::make(*this, p);
    return pieceOf(king.bsf()+PtypeFuns<KING>::indexNum*32);
  const Square from = last_move.from(), to = last_move.to();
  if (promoteMask!=0 && num < PtypeTraits<PAWN>::indexLimit)
  ppieces = effect.getMask(index) & promoted.getMask(index);
  return ConditionAdaptor<OpenCheck>::isMember(*this, move);
allEffectAt(Player attack, Ptype ptype, Square target) const
bool osl::NumEffectState::isConsistent(bool showError) const
void osl::NumEffectState::showEffect(std::ostream& os) const
                                    kingSquare(alt(turn())));
                    pin_or_open_backup, king_mobility_backup,
                    pin_or_open_backup, king_mobility_backup,
                  CArray<PieceMask,2>&, CArray<PieceMask,2>&,
                  CArray<PieceMask,2>&, CArray<PieceMask,2>&,
               const CArray<PieceMask,2>& pin_or_open_backup,
             const CArray<PieceMask,2>& effected_mask_backup,
  // 自分自身がブロックしていたpromote?の延長
  PieceMask pieces = piecesOnBoard(P) & effectedMask(alt(P));
void osl::NumEffectState::copyFrom(const NumEffectState& src)
                const CArray<PieceMask,2>& pin_or_open_backup,
  effects.doBlockAt<NumBitmapEffect::Add,false>(*this,to,num);
bool osl::NumEffectState::isPawnDropCheckmate(Move move) const
               const CArray<PieceMask,2>& effected_mask_backup,
             CArray<PieceMask,2>& effected_changed_mask_backup,
    return pieceOf(ppieces.bsf()+PtypeFuns<PAWN>::indexNum*32);
  effected_changed_mask_backup = effects.effected_changed_mask;
  effected_changed_mask_backup = effects.effected_changed_mask;
  effected_changed_mask_backup = effects.effected_changed_mask;
  effects.effected_changed_mask = effected_changed_mask_backup;
  effects.effected_changed_mask = effected_changed_mask_backup;
  effects.effected_changed_mask = effected_changed_mask_backup;
  return PlayerMoveAdaptor<DirectCheck>::isMember(*this, move);
                const CArray<PieceMask,2>& effected_mask_backup,
      return pieceOf(pieces.bsf()+PtypeFuns<PAWN>::indexNum*32);
    prologueSimple(Player2Type<BLACK>(), from, to, promoteMask, 
    prologueSimple(Player2Type<WHITE>(), from, to, promoteMask, 
    return pieceOf(pieces.any() ? pieces.bsf() : ppieces.bsf());
    return pieceOf(ppieces.bsf()+PtypeFuns<LANCE>::indexNum*32);
  effects.doBlockAt<NumBitmapEffect::Sub,false>(*this,from,num);
  effects.effectedNumTable[num0]=effects.effectedNumTable[num1];
  effects.effectedNumTable[num1]=effects.effectedNumTable[num0];
  pin_or_open[defense]=makePinOpen(kingSquare(defense),defense);
void osl::NumEffectState::generateLegal(MoveVector& moves) const
               CArray<PieceMask,2>& effected_changed_mask_backup,
      return pieceOf(pieces.bsf()+PtypeFuns<LANCE>::indexNum*32);
  const NumBitmapEffect changed_effect_pieces = changedPieces(); 
                  CArray<PieceMask,2>&, KingMobility&, PieceMask&,
                  CArray<PieceMask,2>&, KingMobility&, PieceMask&,
                CArray<PieceMask,2>& effected_changed_mask_backup,
               int&, mask_t&, CArray<PieceMask,2>&, KingMobility&,
               int&, mask_t&, CArray<PieceMask,2>&, KingMobility&,
             int num, PtypeO ptypeO, int numIndex, mask_t numMask,
    BoardMask changed=changedEffects(BLACK)|changedEffects(WHITE);
    BoardMask changed=changedEffects(BLACK)|changedEffects(WHITE);
    BoardMask changed=changedEffects(BLACK)|changedEffects(WHITE);
    mask_t plance = lance & promotedPieces().getMask(lance_index);
  if (Piece_Table.getPtypeOf(num) == Piece_Table.getPtypeOf(nump))
void osl::NumEffectState::generateAllUnsafe(MoveVector& out) const
              != (prev.effectSetAt(sq) & prev.piecesOnBoard(pl))) {
    standMask(P).getMask(numIndex) & Ptype_Table.getMaskLow(ptype);
  NumEffectState::safeCaptureNotByKing<BLACK>(Square, Piece) const;
  NumEffectState::safeCaptureNotByKing<WHITE>(Square, Piece) const;
doCaptureMove(Square from, Square to, Piece target, int promoteMask)
             const CArray<PieceMask,2>& effected_changed_mask_backup,
          if (!(effects1.effectSetAt(pos)==effects.effectSetAt(pos)))
  return PlayerMoveAdaptor<PawnDropCheckmate>::isMember(*this, move);
#if (defined __GNUC__) && (! defined GPSONE) && (! defined GPSUSIONE)
epilogueDrop(Player2Type<P>, Square to, Ptype ptype, Piece oldPiece, 
        std::cerr << "changedPieces() unset\n" << *this << moved << i 
      if (prev.effectedMask(pl).test(i) != effectedMask(pl).test(i)) {
  effects.template doBlockAt<NumBitmapEffect::Sub,true>(*this,to,num);
  effects.template doBlockAt<NumBitmapEffect::Sub,true>(*this,to,num);
#if (defined(__i386__) || defined(__x86_64__)) && !defined(OSL_NO_SSE)
#if (defined(__i386__) || defined(__x86_64__)) && !defined(OSL_NO_SSE)
epilogueCapture(Player2Type<P>, Square from, Square to, Piece target, 
prologueCapture(Player2Type<P>, Square from, Square to, Piece target, 
                  PtypeO&, PtypeO&, PtypeO&, int&, int&, int&, mask_t&,
                  PtypeO&, PtypeO&, PtypeO&, int&, int&, int&, mask_t&,
                 PtypeO&, PtypeO&, CArray<PieceMask,2>&, KingMobility&,
                 PtypeO&, PtypeO&, CArray<PieceMask,2>&, KingMobility&,
               const CArray<PieceMask,2>& effected_changed_mask_backup,
  effects.doEffect<NumBitmapEffect::Sub,false>(*this,newPtypeO,to,num);
  effects.template doBlockAt<NumBitmapEffect::Add,false>(*this,to,num);
  stand_count[P][unpromote(getPtype(capturePtypeO))-PTYPE_BASIC_MIN]++;
  stand_count[P][unpromote(getPtype(capturePtypeO))-PTYPE_BASIC_MIN]--;
prologueSimple(Player2Type<P>, Square from, Square to, int promoteMask,
                  const CArray<PieceMask,2>&, const CArray<uint64_t,2>&,
                  const CArray<PieceMask,2>&, const CArray<uint64_t,2>&,
                 PieceMask&, CArray<PieceMask,2>&, CArray<PieceMask,2>&,
                 PieceMask&, CArray<PieceMask,2>&, CArray<PieceMask,2>&,
                Piece oldPiece, PtypeO oldPtypeO, PtypeO capturePtypeO, 
                const CArray<PieceMask,2>& effected_changed_mask_backup,
      (*this).board[Square(x,y).index()]=src.board[Square(x,y).index()];
    if(changed.anyInRange(Board_Mask_Table3x3.mask(kingSquare<BLACK>()))
    if(changed.anyInRange(Board_Mask_Table3x3.mask(kingSquare<BLACK>()))
    if(changed.anyInRange(Board_Mask_Table3x3.mask(kingSquare<BLACK>()))
    if(changed.anyInRange(Board_Mask_Table3x3.mask(kingSquare<WHITE>()))
    if(changed.anyInRange(Board_Mask_Table3x3.mask(kingSquare<WHITE>()))
    if(changed.anyInRange(Board_Mask_Table3x3.mask(kingSquare<WHITE>()))
  effects.template doBlockAt<NumBitmapEffect::Add,true>(*this,from,num);
  prologueSimple(Player2Type<BLACK>, Square, Square, int, Piece&, int&, 
  prologueSimple(Player2Type<WHITE>, Square, Square, int, Piece&, int&, 
      notpromoted &= ~Ptype_Table.getMaskLow(Piece_Table.getPtypeOf(pp));
    !=primDirUnsafe(Board_Table.getShort8Unsafe(piece.owner(), from,to));
  effects.doEffect<NumBitmapEffect::Add,false>(*this,oldPtypeO,from,num);
  effects.template doBlockAt<NumBitmapEffect::Add,true>(*this,from,num0);
  prologueCapture(Player2Type<BLACK>, Square, Square, Piece, int, Piece&,
  prologueCapture(Player2Type<WHITE>, Square, Square, Piece, int, Piece&,
  prologueDrop(Player2Type<BLACK>, Square, Ptype, Piece&, int&, PtypeO&, 
  prologueDrop(Player2Type<WHITE>, Square, Ptype, Piece&, int&, PtypeO&, 
  effects.template doBlockAt<NumBitmapEffect::Sub,false>(*this,from,num0);
                Piece& oldPiece, PtypeO& oldPtypeO, PtypeO& capturePtypeO, 
  const int lance_index = PtypeFuns<LANCE>::indexNum; // 64bit: 0, 32bit: 1
  king8infos[P]=King8Info::make<altP>(*this,kingSquare<P>()).uint64Value();
                  PtypeO, int, int, int, mask_t, const CArray<PieceMask,2>&,
                  PtypeO, int, int, int, mask_t, const CArray<PieceMask,2>&,
  effects.template doEffect<NumBitmapEffect::Add,true>(*this,ptypeO,to,num);
    if (King8Info(Iking8Info(p)).uint64Value() != king8info2.uint64Value()) {
  effects.template doEffect<NumBitmapEffect::Sub,false>(*this,ptypeO,to,num);
                    capturePtypeO, newPtypeO, num0, num1, num1Index,num1Mask, 
                    capturePtypeO, newPtypeO, num0, num1, num1Index,num1Mask, 
    std::copy_if(all_moves.begin(), all_moves.end(), std::back_inserter(moves),
  move_generator::AllMoves<move_action::Store>::generate(turn(), *this, store);
/* ------------------------------------------------------------------------- */
void osl::NumEffectState::generateWithFullUnpromotions(MoveVector& moves) const
                   return this->isSafeMove(m) && ! this->isPawnDropCheckmate(m);
                  << " " << each_effect[i] << " != " <<  prev_effect[i] << "\n";
  const BoardMask changed_all = changed_squares[BLACK] | changed_squares[WHITE];
  effects.template doEffect<NumBitmapEffect::Add,true>(*this,new_ptypeo,to,num);
  effects.template doEffect<NumBitmapEffect::Add,true>(*this,new_ptypeo,to,num0);
  effects.template doEffect<NumBitmapEffect::Sub,false>(*this,newPtypeO,to,num0);
  effects.template doEffect<NumBitmapEffect::Sub,true>(*this,oldPtypeO,from,num);
          if(effects.effectedNumTable[num][d]!=effects1.effectedNumTable[num][d]){
  effects.template doEffect<NumBitmapEffect::Sub,true>(*this,oldPtypeO,from,num0);
  epilogueDrop(Player2Type<BLACK>, Square, Ptype, Piece, int, PtypeO, int, mask_t,
  epilogueDrop(Player2Type<WHITE>, Square, Ptype, Piece, int, PtypeO, int, mask_t,
  effects.template doEffect<NumBitmapEffect::Add,false>(*this,oldPtypeO,from,num0);
                  const KingMobility&, const PieceMask&, const CArray<PieceMask,2>&,
                  const KingMobility&, const PieceMask&, const CArray<PieceMask,2>&,
  effects.template doEffect<NumBitmapEffect::Sub,true>(*this,capturePtypeO,to,num1);
  epilogueCapture(Player2Type<BLACK>, Square, Square, Piece, Piece, PtypeO, PtypeO, 
  epilogueCapture(Player2Type<WHITE>, Square, Square, Piece, Piece, PtypeO, PtypeO, 
        std::cerr << "pin for " << p << " differs " << pin(p) << " " << pin2 << "\n";
  effects.template doEffect<NumBitmapEffect::Add,false>(*this,capturePtypeO,to,num1);
            std::cerr << "effectedChanged(" << pl << ") unset\n" << *this << moved << i 
               const CArray<PieceMask,2>&, const KingMobility&, const CArray<PieceMask,2>&,
               const CArray<PieceMask,2>&, const KingMobility&, const CArray<PieceMask,2>&,
               const CArray<PieceMask,2>&, const CArray<uint64_t,2>&, const MobilityTable&);
            std::cerr << "changedEffects unset\n" << *this << moved << sq << "\n";          
    prologueDrop(Player2Type<BLACK>(), to, ptype, oldPiece, num, ptypeO, numIndex, numMask, 
    prologueDrop(Player2Type<WHITE>(), to, ptype, oldPiece, num, ptypeO, numIndex, numMask, 
               const CArray<PieceMask,2>&, const CArray<uint64_t,2>&, const MobilityTable&);  
    // この指手は，玉の素抜きがあったり，打歩詰の可能性があるので
    prologueCapture(Player2Type<BLACK>(), from, to, target, promoteMask, oldPiece, oldPtypeO, 
    prologueCapture(Player2Type<WHITE>(), from, to, target, promoteMask, oldPiece, oldPtypeO, 
    // 王手がかかっている時は防ぐ手のみを生成, 王手回避は不成も生成
  // depends on current piece numbers: <FU 0>, KE 18, GI 22, KI 26, <OU 30>, <KY 32>, KA 36, HI 38, 
                 effected_mask_backup, effected_changed_mask_backup,king8infos_backup,mobilityTable);
                 effected_mask_backup, effected_changed_mask_backup,king8infos_backup,mobilityTable);
              std::cerr << "changedEffects unset for " << pl << "\n" << *this << moved << sq << "\n";
bool osl::NumEffectState::isConsistent(const NumEffectState& prev, Move moved, bool show_error) const
          std::cerr << "promoted differs " << p << " " << promoted << " " << promoted.test(i) << "\n";
                      << " " << prev.effectedChanged(pl) << " != " << prev.effectedChanged(WHITE) << "\n";
        std::cerr << "king8info for " << p << " differs \n" << King8Info(Iking8Info(p)) << "\n" << king8info2 << "\n";
                   promoted_backup, effected_mask_backup, effected_changed_mask_backup,king8infos_backup,mobilityTable);
                   promoted_backup, effected_mask_backup, effected_changed_mask_backup,king8infos_backup,mobilityTable);
                    promoted_backup, effected_mask_backup, effected_changed_mask_backup,king8infos_backup,mobilityTable);
                    promoted_backup, effected_mask_backup, effected_changed_mask_backup,king8infos_backup,mobilityTable);
            std::cerr << pos << ",real=" << effects.effectSetAt(pos) << ",ideal=" << effects1.effectSetAt(pos) << std::endl;
            std::cerr << "piece=" << pieceOf(num) << ",num=" << num << ",d=" << d << ",v1=" << effects.effectedNumTable[num][d] << ",v2=" << effects1.effectedNumTable[num][d] << std::endl;