root/06/devel-old/pattern.cc

// File: pattern.cc

//   Copyright (C) 2001-6 Ulrich Goertz (u@g0ertz.de)

//   This file is part of Kombilo 0.6, a go database program.

//   This program is free software; you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation; either version 2 of the License, or
//   (at your option) any later version.

//   This program is distributed in the hope that it will be useful,
//   but WITHOUT ANY WARRANTY; without even the implied warranty of
//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//   GNU General Public License for more details.

//   You should have received a copy of the GNU General Public License
//   along with this program (see doc/license.txt); if not, write to the Free Software
//   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//   The GNU GPL is also currently available at
//   http://www.gnu.org/copyleft/gpl.html

// --------------------------------------------------------------------------

#include "pattern.h"
#include <iostream>

Symmetries::Symmetries(int sX, int sY) {
  cout << "Enter method Symmetries::Symmetries" << endl; 
  sizeX = sX;
  sizeY = sY;
  dataX = new int[sizeX*sizeY];
  dataY = new int[sizeX*sizeY];
  dataCS = new int[sizeX*sizeY];
  for(int i=0; i<sizeX*sizeY; i++) {
    dataX[i] = -1;
    dataY[i] = -1;
    dataCS[i] = -1;
  }
  special = -1;
}


Symmetries::~Symmetries() {
  delete [] dataX;
  delete [] dataY;
  delete [] dataCS;
}

Symmetries::Symmetries(const Symmetries& s) {
  sizeX = s.sizeX;
  sizeY = s.sizeY;
  dataX = new int[sizeX*sizeY];
  dataY = new int[sizeX*sizeY];
  dataCS = new int[sizeX*sizeY];
  for(int i=0; i<sizeX*sizeY; i++) {
    dataX[i] = s.dataX[i];
    dataY[i] = s.dataY[i];
    dataCS[i] = s.dataCS[i];
  }
  special = s.special;
}

Symmetries& Symmetries::operator=(const Symmetries& s) {
  if (&s != this) {
    sizeX = s.sizeX;
    sizeY = s.sizeY;
    delete [] dataX;
    delete [] dataY;
    delete [] dataCS;
    dataX = new int[sizeX*sizeY];
    dataY = new int[sizeX*sizeY];
    dataCS = new int[sizeX*sizeY];
    for(int i=0; i<sizeX*sizeY; i++) {
      dataX[i] = s.dataX[i];
      dataY[i] = s.dataY[i];
      dataCS[i] = s.dataCS[i];
    }
    special = s.special;
  }
  return *this;
}

void Symmetries::set(int i, int j, int k, int l, int cs) {
  if (0 <= i && i < sizeX && 0 <= j && j < sizeY) {
    dataX[i + j*sizeX] = k;
    dataY[i + j*sizeX] = l;
    dataCS[i + j*sizeX] = cs;
  }
  else printf("Error Symmetries1\n"); // FIXME
}

int Symmetries::getX(int i, int j) {
  if (0 <= i && i < sizeX && 0 <= j && j < sizeY) return dataX[i + j*sizeX];
  else printf("Error Symmetries2\n"); // FIXME
  return -1;
}

int Symmetries::getY(int i, int j) {
  if (0 <= i && i < sizeX && 0 <= j && j < sizeY) return dataY[i + j*sizeX];
  else printf("Error Symmetries3\n"); // FIXME
  return -1;
}

int Symmetries::getCS(int i, int j) {
  if (0 <= i && i < sizeX && 0 <= j && j < sizeY) return dataCS[i + j*sizeX];
  else printf("Error Symmetries4\n"); // FIXME
  return -1;
}

int Symmetries::has_key(int i, int j) {
  if (0 <= i && i < sizeX && 0 <= j && j < sizeY) {
    if (dataX[i + j*sizeX] == -1) return 0;
    else return 1;
  }
  else printf("Error Symmetries5\n"); // FIXME
  return 0;
}



// ----------- class Pattern -----------------------------------------------

int Pattern::operator==(const Pattern& p) {
  if (sizeX != p.sizeX || sizeY != p.sizeY) return 0;
  if (left != p.left || right != p.right || top != p.top || bottom != p.bottom) return 0; 
  if (moveOne != p.moveOne) return 0;
  for(int i=0; i < sizeX*sizeY; i++)
    if (initialPos[i] != p.initialPos[i]) return 0;
  for(int i=0; i < 4*lenContList; i++)
    if (contList[i] != p.contList[i]) return 0; 
  return 1;
}


char Pattern::BW2XO(char c) {
  if (c == 'B') return 'X';
  if (c == 'W') return 'O';
  return c;
}

char Pattern::getInitial(int i, int j) {
  return initialPos[i + sizeX*j];
}
 
char Pattern::getFinal(int i, int j) {
  return finalPos[i + sizeX*j];
}
 
int Pattern::getBits(int b, int i) {
  return (int)bits[b][i];
}


Pattern::Pattern() {
  // cout << "Enter method Pattern::Pattern()" << endl; 
  initialPos = 0;
  finalPos = 0;
  contList = 0;
  bits = 0;
  bitlengths = 0; // FIXME?!
}


Pattern::Pattern(int le, int ri, int to, int bo, int sX, int sY,
                 char* iPos, char* cList, int lenCList, char mOne) {
  // cout << "Enter method Pattern::Pattern" << endl; 
  flip = 0;
  colorSwitch = 0;
  if (mOne=='B' || mOne=='X') moveOne = 'X';
  else moveOne = 'O';
  if (moveOne == 'X') moveTwo = 'O';
  else moveTwo = 'X';
       
  left = le;
  right = ri;
  top = to;
  bottom = bo;

  // anchors.sort();
        
  sizeX = sX;
  sizeY = sY;

  initialPos = new char[sizeX * sizeY];
  finalPos = new char[sizeX*sizeY];
  for(int i=0; i<sizeX*sizeY; i++) {
    initialPos[i] = iPos[i];
    finalPos[i] = iPos[i];
  }

  lenContList = lenCList;
  contList = new char[lenCList*4+1];
  for(int i=0; i<4*lenCList; i++) contList[i] = cList[i];
  for(int i=0; i<lenContList; i++) {
    finalPos[contList[4*i] + sizeX * contList[4*i+1]] = BW2XO(contList[4*i+2]);
  }
  contList[lenCList*4] = 0;

  bits = new charp[4];
  bitlengths = new int[4];

  for(int i=0; i<2; i++) {
    for(int j=0; j<2; j++) {
      int xBlocks = (sizeY+i+1)/2;
      int yBlocks = (sizeX+j+1)/2;
      char* nextBlock = new char[400];
      int nextBlockIndex = 0;
      nextBlock[nextBlockIndex++] = yBlocks;

      for(int k1=0; k1 < yBlocks; k1++) {
        char nlist[400];
        int nlistIndex = 0;

        for(int k2=0; k2 < xBlocks; k2++) {
          int n = 0;
          for(int x=0; x<2; x++) {
            for(int y=0; y<2; y++) {
              int indexX = k1 * 2 + y - j;
              int indexY = k2 * 2 + x - i;
              if (0 <= indexX && indexX < sizeX && 0 <= indexY && indexY < sizeY) {
                if (getFinal(indexX,indexY)=='X')
                  n |= 1 << (2*(2*x+y));
                else if (getFinal(indexX,indexY)=='O')
                  n |= 1 << (2*(2*x+y)+1);
              }
            }
          }
          nlist[nlistIndex++] = n;
        }              

        int start = 0;
        int end = nlistIndex;

        while (start < end && !nlist[start]) start++;
        while (end > start && !nlist[end-1]) end--;

        nextBlock[nextBlockIndex++] = start;
        nextBlock[nextBlockIndex++] = end-start;
        for(int current=start; current < end; current++) 
          nextBlock[nextBlockIndex++] = nlist[current];
      }
      char* nB = new char[nextBlockIndex];
      for(int ii=0; ii<nextBlockIndex; ii++) nB[ii] = nextBlock[ii];
      bitlengths[2*i + j] = nextBlockIndex;
      bits[2*i + j] = nB;
      delete [] nextBlock;
    }
  }
  // cout << "Leave method Pattern::Pattern(...)" << endl; 
}

Pattern::~Pattern() {
  // cout << "Enter method Pattern::~Pattern" << endl; 
  if (initialPos) delete [] initialPos;
  if (finalPos) delete [] finalPos;
  if (contList) delete [] contList;
  if (bitlengths) {
    delete [] bitlengths;
    for(int i=0; i<4; i++)
      if (bits[i]) delete [] bits[i];
    delete [] bits;
  }
  // cout << "Leave method Pattern::~Pattern" << endl; 
}

Pattern::Pattern(const Pattern& p) {
  // cout << "Enter method Pattern::Pattern(const Pattern&)" << endl; 
  left = p.left;
  right = p.right;
  top = p.top;
  bottom = p.bottom;
  sizeX = p.sizeX;
  sizeY = p.sizeY;
  flip = p.flip;
  colorSwitch = p.colorSwitch;
  moveOne = p.moveOne;
  moveTwo = p.moveTwo;

  initialPos = new char[sizeX*sizeY];
  finalPos = new char[sizeX*sizeY];
  for(int i=0; i<sizeX*sizeY; i++) {
    initialPos[i] = p.initialPos[i];
    finalPos[i] = p.finalPos[i];
  }
  lenContList = p.lenContList;
  if (lenContList) {
    contList = new char[lenContList*4];
    for(int i = 0; i < lenContList*4; i++) contList[i] = p.contList[i];
  }
  else contList = 0;
  if (p.bitlengths) {
    bits = new charp[4];
    bitlengths = new int[4];

    for(int i=0; i<4; i++) {
      bitlengths[i] = p.bitlengths[i];
      if (bitlengths[i]>0) bits[i] = new char[bitlengths[i]];
      else {
        bits[i] = 0;
        continue;
      }
      for(int j=0; j<bitlengths[i]; j++)
        bits[i][j] = p.bits[i][j];
    }
  }
  else {
    bits = 0;
    bitlengths = 0;
  }
}

Pattern& Pattern::copy(const Pattern& p) {
  cout << "Enter method Pattern::copy" << endl; 
  if (&p != this) {
    left = p.left;
    right = p.right;
    top = p.top;
    bottom = p.bottom;
    sizeX = p.sizeX;
    sizeY = p.sizeY;
    flip = p.flip;
    colorSwitch = p.colorSwitch;
    moveOne = p.moveOne;
    moveTwo = p.moveTwo;

    if (initialPos) delete [] initialPos;
    if (finalPos) delete [] finalPos;
    if (contList) delete [] contList;
    if (bits) delete [] bits;
    if (bitlengths) delete [] bitlengths;
    
    initialPos = new char[sizeX*sizeY];
    finalPos = new char[sizeX*sizeY];
    for(int i=0; i<sizeX*sizeY; i++) {
      initialPos[i] = p.initialPos[i];
      finalPos[i] = p.finalPos[i];
    }
    lenContList = p.lenContList;
    contList = new char[lenContList*4+1];
    for(int i = 0; i < lenContList*4; i++) contList[i] = p.contList[i];
    contList[lenContList*4] = 0;

    if (p.bitlengths) {
      bits = new charp[4];
      bitlengths = new int[4];

      for(int i=0; i<4; i++) {
        bitlengths[i] = p.bitlengths[i];
        if (bitlengths[i]>0) bits[i] = new char[bitlengths[i]];
        else {
          bits[i] = 0;
          continue;
        }
        for(int j=0; j<bitlengths[i]; j++)
          bits[i][j] = p.bits[i][j];
      }
    }
    else {
      bits = 0;
      bitlengths = 0;
    }
  }
  return *this;
  cout << "Leave method Pattern::copy " << endl; 
}

void Pattern::printPattern() {
  printf("print pattern\n");
}


int Pattern::flipsX(int i, int x, int y, int XX, int YY) {
  if (i==0) return x;
  if (i==1) return XX-x;
  if (i==2) return x;
  if (i==3) return XX-x;
  if (i==4) return y;
  if (i==5) return YY-y;
  if (i==6) return y;
  if (i==7) return YY-y;
  return -1;
}

int Pattern::flipsY(int i, int x, int y, int XX, int YY) {
  if (i==0) return y;
  if (i==1) return y;
  if (i==2) return YY-y;
  if (i==3) return YY-y;
  if (i==4) return x;
  if (i==5) return x;
  if (i==6) return XX-x;
  if (i==7) return XX-x;
  return -1;
}


int Pattern::PatternInvFlip(int i) {
  if (i == 5) return 6;
  if (i == 6) return 5;
  return i;
}

PatternList::PatternList(Pattern& p, int fColor, int nMove, int bsize) {
  // cout << "Enter method PatternList::PatternList(...)" << endl; 
  pattern.copy(p);
  fixedColor = fColor;
  nextMove = nMove;
  boardsize = bsize;
  // cout << "BP1" << endl; 

  data = patternList();
  // cout << "Leave method PatternList::PatternList(...)" << endl; 
}


PatternList::PatternList(const PatternList& pl) {
  printf("OUCH. Copy constructor for PatternList needed.\n"); // FIXME
}

PatternList& PatternList::operator=(const PatternList& pl) {
  printf("OUCH. operator= for PatternList needed.\n"); // FIXME
  return *this;
}

        
char PatternList::invertColor(char co) {
  if (co == 'X') return 'O';
  if (co == 'x') return 'o';

  if (co == 'O') return 'X';
  if (co == 'o') return 'x';

  return co;
}
        
vector<Pattern> PatternList::patternList() {
  cout << "Enter method PatternList::patternList" << endl; 
        
  vector<Pattern> l;
  vector<Pattern> lCS;
  vector<pair<int,int> > sy;
  int special = -1;

  for(int f = 0; f < 8; f++) {
    int newSizeX = max(Pattern::flipsX(f,0,0,pattern.sizeX,pattern.sizeY),
                       Pattern::flipsX(f,pattern.sizeX,pattern.sizeY,pattern.sizeX,pattern.sizeY));
    int newSizeY = max(Pattern::flipsY(f,0,0,pattern.sizeX,pattern.sizeY),
                       Pattern::flipsY(f,pattern.sizeX,pattern.sizeY,pattern.sizeX,pattern.sizeY));

    int newLeft = min(Pattern::flipsX(f,pattern.left,pattern.top,boardsize-1,boardsize-1),
                      Pattern::flipsX(f,pattern.right+pattern.sizeX-1,pattern.bottom+pattern.sizeY-1,
                                      boardsize-1,boardsize-1));
    int newRight = max(Pattern::flipsX(f,pattern.left,pattern.top,boardsize-1,boardsize-1),
                       Pattern::flipsX(f,pattern.right+pattern.sizeX-1,pattern.bottom+pattern.sizeY-1,
                                       boardsize-1,boardsize-1)) - (newSizeX-1);
    int newTop = min(Pattern::flipsY(f,pattern.left,pattern.top,boardsize-1,boardsize-1),
                     Pattern::flipsY(f,pattern.right+pattern.sizeX-1,pattern.bottom+pattern.sizeY-1,
                                     boardsize-1,boardsize-1));
    int newBottom = max(Pattern::flipsY(f,pattern.left,pattern.top,boardsize-1,boardsize-1),
                        Pattern::flipsY(f,pattern.right+pattern.sizeX-1,pattern.bottom+pattern.sizeY-1,
                        boardsize-1,boardsize-1)) - (newSizeY - 1);

    // printf("%d, %d, %d, %d, %d, %d, %d\n", f, newSizeX, newSizeY, newLeft, newRight, newTop, newBottom);
    char* newInitialPos = new char[pattern.sizeX*pattern.sizeY];
    for(int i=0; i<pattern.sizeX; i++) {
      for(int j=0; j<pattern.sizeY; j++) {
        newInitialPos[Pattern::flipsX(f,i,j,pattern.sizeX-1,pattern.sizeY-1) + \
                      newSizeX*Pattern::flipsY(f,i,j,pattern.sizeX-1,pattern.sizeY-1)] = pattern.getInitial(i, j);
      }
    }

    char* newContList = new char[pattern.lenContList*4+1];
    for(int i=0; i<pattern.lenContList; i++) {
      newContList[4*i] = Pattern::flipsX(f, pattern.contList[4*i], pattern.contList[4*i+1],
                                         pattern.sizeX-1,pattern.sizeY-1);
      newContList[4*i+1] = Pattern::flipsY(f, pattern.contList[4*i], pattern.contList[4*i+1],
                                              pattern.sizeX-1,pattern.sizeY-1);
      newContList[4*i+2] = pattern.contList[4*i+2];
      newContList[4*i+3] = '/'; // FIXME: ist doch so Verschwendung
    }
    newContList[pattern.lenContList*4] = 0;

    // cout << "BP0" << endl;
    Pattern pNew(newLeft, newRight, newTop, newBottom, newSizeX, newSizeY,
                 newInitialPos, newContList, pattern.lenContList, pattern.moveOne);

    pNew.flip = f;
    // cout << "BP1" << endl;

    delete [] newInitialPos;
    delete [] newContList;
    // cout << "BP1.5" << endl;

    vector<Pattern>::iterator it;
    bool foundNewPattern = true;
    for(it = l.begin(); it != l.end(); it++) {
      if (pNew == *it) {
        foundNewPattern = false;
        break;
      }
    }
    if (foundNewPattern) l.push_back(pNew);

    if (pNew == pattern) sy.push_back(pair<int,int>(f,0));
    // cout << "BP2" << endl; 

    if (nextMove || !fixedColor) {
      // FIXME: nach flip "entspricht" links oben nicht mehr 0,0, also newInitialPos, newContList anpassen
      // FIXME ... verstehe diese Bemerkung nicht!!!
      // FIXME
      char* newInitialPos = new char[pattern.sizeX*pattern.sizeY];
      for(int i=0; i<pattern.sizeX; i++) {
        for(int j=0; j<pattern.sizeY; j++) {
          newInitialPos[Pattern::flipsX(f,i,j,pattern.sizeX-1,pattern.sizeY-1) + newSizeX*Pattern::flipsY(f,i,j,pattern.sizeX-1,pattern.sizeY-1)] =
            invertColor(pattern.getInitial(i, j));
        }
      }

      char* newContList = new char[pattern.lenContList*4+1];
      for(int i=0; i<pattern.lenContList; i++) {
        newContList[4*i] = Pattern::flipsX(f, pattern.contList[4*i], pattern.contList[4*i+1], pattern.sizeX-1,pattern.sizeY-1);
        newContList[4*i+1] = Pattern::flipsY(f, pattern.contList[4*i], pattern.contList[4*i+1], pattern.sizeX-1,pattern.sizeY-1);
        newContList[4*i+2] = invertColor(pattern.contList[4*i+2]);
        newContList[4*i+3] = '/'; // FIXME siehe oben
      }
      newContList[pattern.lenContList*4] = 0;

      Pattern pNew1(newLeft, newRight, newTop, newBottom, newSizeX, newSizeY,
                    newInitialPos, newContList, pattern.lenContList, pattern.moveTwo);
      pNew1.flip = f;
      pNew1.colorSwitch = 1;

      delete [] newInitialPos;
      delete [] newContList;

      if (!fixedColor) {
        vector<Pattern>::iterator it;
        bool foundNewPattern = true;
        for(it = lCS.begin(); it != lCS.end(); it++) {
          if (pNew1 == *it) {
            foundNewPattern = false;
            break;
          }
        }
        if (foundNewPattern) l.push_back(pNew1);
      }

      if (pNew1 == pattern) {
        if (!fixedColor) sy.push_back(pair<int,int>(f,1));
        if (nextMove) special = f;
      }
    }
  }

  vector<Pattern>::iterator it;
  for(it = lCS.begin(); it != lCS.end(); it++) {
    vector<Pattern>::iterator it_l;
    bool contained_in_l = false;
    for(it_l = l.begin(); it_l != l.begin(); it_l++)
      if (*it == *it_l) {
        contained_in_l = true;
        break;
      }
    if (!contained_in_l) l.push_back(*it);
  }

  Symmetries symm(pattern.sizeX, pattern.sizeY);
  for(int i=0; i<symm.sizeX; i++)
    for(int j=0; j<symm.sizeY; j++)
      symm.set(i,j,i,j,0);

  vector<pair<int,int> >::iterator it_s;
  for(it_s=sy.begin(); it_s!=sy.end(); it_s++) {
    int s = it_s->first;
    int newSizeX = max(Pattern::flipsX(s,0,0,pattern.sizeX,pattern.sizeY),
                       Pattern::flipsX(s,pattern.sizeX,pattern.sizeY,pattern.sizeX,pattern.sizeY));
    int newSizeY = max(Pattern::flipsY(s,0,0,pattern.sizeX,pattern.sizeY),
                       Pattern::flipsY(s,pattern.sizeX,pattern.sizeY,pattern.sizeX,pattern.sizeY));
    int c = it_s->second;
    Symmetries symm1(newSizeX, newSizeY);

    for(int i=0; i < pattern.sizeX; i++) {
      for(int j=0; j < pattern.sizeY; j++) {
        int fX = Pattern::flipsX(s, i, j, pattern.sizeX-1, pattern.sizeY-1);
        int fY = Pattern::flipsY(s, i, j, pattern.sizeX-1, pattern.sizeY-1);
        if ((i != fX || j != fY) && !symm1.has_key(fX, fY))
          symm1.set(i,j, fX, fY, c);
      }
    }

    int cs;
    for(int i=0; i<symm.sizeX; i++)
      for(int j=0; j<symm.sizeY; j++)
        if (symm1.has_key(symm.getX(i,j), symm.getY(i,j))) {
          if ((symm1.getCS(symm.getX(i,j),symm.getY(i,j)) || symm.getCS(i,j)) && 
              !(symm1.getCS(symm.getX(i,j),symm.getY(i,j)) && symm.getCS(i,j)))
            cs = 1;
          else cs = 0;
          symm.set(i,j,symm1.getX(symm.getX(i,j),symm.getY(i,j)), 
              symm1.getY(symm.getX(i,j),symm.getY(i,j)), cs);
        }
  }

  if (special == -1)
    symm.special = -1;
  else
    symm.special = Pattern::PatternInvFlip(special);

  symmetries = symm;
  return l;
  cout << "Leave method PatternList::patternList" << endl; 
}


Pattern& PatternList::get(int i) {
  return data[i];
}


int PatternList::size() {
  return data.size();
}


PyObject* PatternList::updateContinuations(int index, int x, int y, char co, int Xint0, int Xint1, 
    int Yint0, int Yint1,
    int foundWhere, int counter,
    PyObject* continuations, char* contLabels, int contLabelsIndex,
    char winner) {

  int xx = Pattern::flipsX(Pattern::PatternInvFlip(data[index].flip), x, y, boardsize-1, boardsize-1);
  int yy = Pattern::flipsY(Pattern::PatternInvFlip(data[index].flip), x, y, boardsize-1, boardsize-1);

  int XX1 = Pattern::flipsX(Pattern::PatternInvFlip(data[index].flip), Xint0, Yint0, boardsize-1, boardsize-1);
  int YY1 = Pattern::flipsY(Pattern::PatternInvFlip(data[index].flip), Xint0, Yint0, boardsize-1, boardsize-1);
  int XX2 = Pattern::flipsX(Pattern::PatternInvFlip(data[index].flip), Xint1-1, Yint1-1, boardsize-1, boardsize-1);
  int YY2 = Pattern::flipsY(Pattern::PatternInvFlip(data[index].flip), Xint1-1, Yint1-1, boardsize-1, boardsize-1);

  int XX = XX1 < XX2 ? XX1 : XX2;
  int YY = YY1 < YY2 ? YY1 : YY2;

  xx -= XX;
  yy -= YY;

  char cc;
  if ((data[index].colorSwitch && co == 'X') || (!data[index].colorSwitch && co == 'O'))
    cc = 'B';
  else cc = 'W';

  int xxN = symmetries.getX(xx,yy);
  int yyN = symmetries.getY(xx,yy);
  int cSymm = symmetries.getCS(xx,yy);

  xx = xxN;
  yy = yyN;

  if ((cc == 'B' && !cSymm) || (cc=='W' && cSymm)) cc = 'B';
  else cc = 'W';

  int colorSwitch;

  if (nextMove) {
    if ((nextMove == 2 && cc == 'B') || (nextMove == 1 && cc == 'W')) {
      if (symmetries.special != -1 && !fixedColor) {

        if (cc == 'B') cc='W';
        else cc = 'B';

        xx += XX;
        yy += YY;

        xxN = Pattern::flipsX(symmetries.special, xx, yy, boardsize-1, boardsize-1);
        yyN = Pattern::flipsY(symmetries.special, xx, yy, boardsize-1, boardsize-1);
        xx = xxN;
        yy = yyN;

        int XX1N = Pattern::flipsX(symmetries.special, XX1, YY1, boardsize-1, boardsize-1);
        int YY1N = Pattern::flipsY(symmetries.special, XX1, YY1, boardsize-1, boardsize-1);
        XX1 = XX1N;
        YY1 = YY1N;

        int XX2N = Pattern::flipsX(symmetries.special, XX2, YY2, boardsize-1, boardsize-1);
        int YY2N = Pattern::flipsY(symmetries.special, XX2, YY2, boardsize-1, boardsize-1);
        XX2 = XX2N;
        YY2 = YY2N;

        XX = XX1 < XX2 ? XX1 : XX2;
        YY = YY1 < YY2 ? YY1 : YY2;

        xx -= XX;
        yy -= YY;

        int xx1 = symmetries.getX(xx,yy);
        int yy1 = symmetries.getY(xx,yy);
        int cSymm1 = symmetries.getCS(xx,yy);

        if (!cSymm1) {
          xx = xx1;
          yy = yy1;
        }

        colorSwitch = 1-cSymm;
        // if (colorSwitch) numOfSwitched++; // FIXME?!
      }
      else
        return Py_BuildValue("iiii",0,0,0,0); 
    }
    else {
      colorSwitch = cSymm;
      // if (colorSwitch) numOfSwitched++;
    }
  }
  else colorSwitch = cSymm;

  PyObject* xxyyPY = Py_BuildValue("(ii)", xx, yy);
  PyObject* scxy;

  char text;
  char ccStr[2];
  ccStr[0] = cc;
  ccStr[1] = 0;
  if ((scxy = PyDict_GetItem(continuations, xxyyPY))) {
    PyObject *temp = PyInt_FromLong(PyInt_AsLong(PyDict_GetItemString(scxy, ccStr))+1);
    PyDict_SetItemString(scxy, ccStr, temp);
    Py_DECREF(temp);
    text = PyString_AsString(PyDict_GetItemString(scxy, "N"))[0];
  }
  else {
    if (contLabelsIndex >= strlen(contLabels)) text = '?'; // FIXME strlen(contLabels) OK?
    else {
      text = contLabels[contLabelsIndex];
      contLabelsIndex++;
    }

    if (cc=='B') {
      scxy = PyDict_New();
      PyObject* Py0 = PyInt_FromLong(0);
      PyObject *Py1 = PyInt_FromLong(1);
      PyDict_SetItemString(scxy, "B", Py1);
      PyDict_SetItemString(scxy, "W", Py0);
      PyDict_SetItemString(scxy, "tB", Py0);
      PyDict_SetItemString(scxy, "tW", Py0);
      PyDict_SetItemString(scxy, "wB", Py0);
      PyDict_SetItemString(scxy, "lB", Py0);
      PyDict_SetItemString(scxy, "wW", Py0);
      PyDict_SetItemString(scxy, "lW", Py0);
      PyDict_SetItemString(scxy, "N", PyString_FromStringAndSize(&text, 1));
      Py_DECREF(Py0);
      Py_DECREF(Py1);
      PyDict_SetItem(continuations, xxyyPY, scxy);
      Py_DECREF(scxy);
    }
    else {
      scxy = PyDict_New();
      PyObject *Py0 = PyInt_FromLong(0);
      PyObject *Py1 = PyInt_FromLong(1);
      PyDict_SetItemString(scxy, "B", Py0);
      PyDict_SetItemString(scxy, "W", Py1);
      PyDict_SetItemString(scxy, "tB", Py0);
      PyDict_SetItemString(scxy, "tW", Py0);
      PyDict_SetItemString(scxy, "wB", Py0);
      PyDict_SetItemString(scxy, "lB", Py0);
      PyDict_SetItemString(scxy, "wW", Py0);
      PyDict_SetItemString(scxy, "lW", Py0);
      PyDict_SetItemString(scxy, "N", PyString_FromStringAndSize(&text, 1));
      Py_DECREF(Py0);
      Py_DECREF(Py1);
      PyDict_SetItem(continuations, xxyyPY, scxy);
      Py_DECREF(scxy);
    }

    Py_DECREF(xxyyPY);

    char tcc[3]; tcc[0]='t'; tcc[1]=cc; tcc[2]=0;
    char lcc[3]; lcc[0]='l'; lcc[1]=cc; lcc[2]=0;
    char wcc[3]; wcc[0]='w'; wcc[1]=cc; wcc[2]=0;

    if (foundWhere != counter && foundWhere != counter+1) {
      PyObject *temp = PyInt_FromLong(PyInt_AsLong(PyDict_GetItemString(scxy, tcc))+1);
      PyDict_SetItemString(scxy, tcc, temp);
      Py_DECREF(temp);
    }

    if (winner == 'B')
      if (!(data[index].colorSwitch || colorSwitch)) {
        PyObject *temp = PyInt_FromLong(PyInt_AsLong(PyDict_GetItemString(scxy, wcc))+1);
        PyDict_SetItemString(scxy, wcc, temp);
        Py_DECREF(temp);
      }
      else {
        PyObject *temp = PyInt_FromLong(PyInt_AsLong(PyDict_GetItemString(scxy, lcc))+1);
        PyDict_SetItemString(scxy, lcc, temp);
        Py_DECREF(temp);
      }
    else if (winner == 'W')
      if (!(data[index].colorSwitch || colorSwitch)) {
        PyObject *temp = PyInt_FromLong(PyInt_AsLong(PyDict_GetItemString(scxy, lcc))+1);
        PyDict_SetItemString(scxy, lcc, temp);
        Py_DECREF(temp);
      }
      else {
        PyObject *temp = PyInt_FromLong(PyInt_AsLong(PyDict_GetItemString(scxy, wcc))+1);
        PyDict_SetItemString(scxy, wcc, temp);
        Py_DECREF(temp);
      }
  }
  return Py_BuildValue("icii", 1, text, contLabelsIndex, 
      (data[index].colorSwitch or colorSwitch));
}