int segment(int[][] input, int[][] itag)
{
  return segmentDeep(input, itag, 0, 60, 0, 60); 
}



int segmentDeep(int[][] input, int[][] itag, int yStart, int yEnd, int xStart, int xEnd)
{
  int numerKsztaltu = 1;
  PVector[] powerTable = new PVector[901];
  int[] tablicaSklejen = new int[901];
  PVector[] sasiedzi;
  PVector maxS;
  PVector minS;
  int maxV, minV;
  
  for (int i = xStart; i < xEnd; ++i)
    for (int j = yStart; j < yEnd; ++j)
      itag[i][j] = 0;
      
  for (int j = yStart; j < yEnd; ++j)
  {
    for (int i = xStart; i < xEnd; ++i)
      if (input[i][j] == 1)
      {
        sasiedzi = neighbours(i, j);
        maxS = maxZero(sasiedzi, itag);
        if ((maxS.x >= 0) && (maxS.x < input.length) && (maxS.y >= 0) && (maxS.y < input.length))
           maxV = itag[int(maxS.x)][int(maxS.y)];
        else
           maxV = 0; 
        if (maxV == 0)
        {
          itag[i][j] = numerKsztaltu;
          powerTable[numerKsztaltu] = new PVector(-2, -2);
          numerKsztaltu = numerKsztaltu + 2;
        }
        else
        {
          
          minS = minZero(sasiedzi, itag);       
          minV = itag[int(minS.x)][int(minS.y)];
          maxV = itag[int(maxS.x)][int(maxS.y)];
          
          itag[i][j] = minV;
          if (minV != maxV)
          {
            powerTable[maxV] = minS;
          }
        }
      }
  }
  
 
  int ret = 0;
  for (int i = 0; i < input.length; ++i)
    for (int j = 0; j < input.length; ++j)
    { 
      if (itag[i][j] != 0) 
      {
        itag[i][j] = getValue(itag[i][j], powerTable, itag);
        if (in(itag[i][j], tablicaSklejen, ret) == -1)
          tablicaSklejen[ret++] = itag[i][j];
      }
    }
    
  for (int i = 0; i < input.length; ++i)
    for (int j = 0; j < input.length; ++j)
      if (itag[i][j] != 0)
        itag[i][j] = in(itag[i][j],tablicaSklejen,ret)*2 + 1;

  return ret;  
}

int in(int n, int[] tablica, int s)
{
  for (int i = 0; i < s; ++i)
  {
    if (tablica[i] == n)
      return i;
  }
  return -1;
}

int getValue(int x, PVector[] powerTable, int[][] itag)
{
  PVector V = powerTable[x];
  if (int(V.x) == -2)
    return x;
  return getValue(itag[int(V.x)][int(V.y)], powerTable, itag);
  
}

PVector minZero(PVector[] input, int[][] itag)
{
  int[] in = new int[input.length]; 
  for (int i = 0; i < input.length; ++i)
  {
    if ((input[i].x >= 0) && (input[i].x < itag.length) && (input[i].y >= 0) && (input[i].y < itag.length))
      in[i] = itag[int(input[i].x)][int(input[i].y)];
    else 
      in[i] = 0;
  }
  int m = max(in);
  PVector ret = new PVector(-1, -1); 
  for (int i = 0; i < in.length; ++i)
  {
    if ((in[i] <= m) && (in[i] != 0))
    {
      m = in[i];
      ret.x = input[i].x;
      ret.y = input[i].y;
    }
  }
  return ret;
}

PVector maxZero(PVector[] input, int[][] itag)
{
  int[] in = new int[input.length]; 
  for (int i = 0; i < input.length; ++i)
    if ((input[i].x >= 0) && (input[i].x < itag.length) && (input[i].y >= 0) && (input[i].y < itag.length))
      in[i] = itag[int(input[i].x)][int(input[i].y)];
    else 
      in[i] = 0; 
  int m = in[0];
  PVector ret = input[0]; 
  for (int i = 1; i < in.length; ++i)
  {
    if (in[i] >= m)
    {
      m = in[i];
      ret.x = input[i].x;
      ret.y = input[i].y;
    }
  }
  //println("X:"+ret.x+";Y:"+ret.y+";m:"+m+";input:"+in[0]+","+in[1]+","+in[2]+","+in[3]);
  return ret;
}

PVector[] neighbours(int i, int j)
{
  PVector[] ret = new PVector[4];
  ret[0] = new PVector(i - 1, j - 1);
  ret[1] = new PVector(i, j - 1);
  ret[2] = new PVector(i + 1, j - 1);
  ret[3] = new PVector(i - 1, j);
  
  return ret;
}

ArrayList bckgrnd(int i, int j, int[][] itag)
{
  ArrayList ret = new ArrayList();
  
  if (j > 0)
    if (itag[i][j - 1] == 0)
      ret.add(new PVector(i, j - 1));  
  if (j < itag.length - 1)
    if (itag[i][j + 1] == 0)
      ret.add(new PVector(i, j + 1)); 
  if (i > 0)
  {
    if (itag[i - 1][j] == 0)
      ret.add(new PVector(i - 1, j)); 
    if (j > 0)
      if (itag[i - 1][j - 1] == 0)
        ret.add(new PVector(i - 1, j - 1));  
    if (j < itag.length - 1)
      if (itag[i - 1][j + 1] == 0)
        ret.add(new PVector(i - 1, j + 1)); 
  }
  if (i < itag.length - 1)
  {
    if (itag[i + 1][j] == 0)
      ret.add(new PVector(i + 1, j)); 
    if (j > 0)
      if (itag[i + 1][j - 1] == 0)
        ret.add(new PVector(i + 1, j - 1));  
    if (j < itag.length - 1)
      if (itag[i + 1][j + 1] == 0)
        ret.add(new PVector(i + 1, j + 1)); 
  }
  
  return ret;
}