Optimizing Conway's Game of Life for an Arduino

I am making Conway's Game of life on an Arduino with a 64x64 dot matrix grid. it is working but its a little slow while running the full size. This is the code that I think is taking the longest:

int same;
int c;

// My code can run in different sizes so these needed to be writable.
int width1=64;
int height=64;

int row0[WIDTH]; // WIDTH is just the constant 64.

void check(int y)
{
  int alive=0;

  for(int x=0;x < width1;++x)
  {
    alive=0;
    if(x > 0)
    {
      if(getPixelColor(x-1, y) > 0)
      {
        alive+=1;
        //Serial.println("(left)");
      }
    
    }
    if(x < width1-1)
    {
      if(getPixelColor(x+1, y) > 0)
      {
        alive+=1;
        //Serial.println("(right)");
      }
    }
    if(y > 0)
    {
      if(getPixelColor(x, y-1) > 0)
      {
        alive+=1;
        //Serial.println("(top)");
      }

      if(x > 0)
      {
        if(getPixelColor(x-1, y-1) > 0)
        {
          alive+=1;
          //Serial.println("(top left)");
        }
      }
      if(x < width1-1)
      {
        if(getPixelColor(x+1, y-1) > 0)
        {
          alive+=1;
          //Serial.println("(top right)");
        }
      }
    }
    if(row < height-1)
    {
      if(getPixelColor(x, y+1) > 0)
      {
        alive+=1;
        //Serial.println("(bottom)");
      }

      if(x > 0)
      {
        if(getPixelColor(x-1, y+1) > 0)
        {
          alive+=1;
          //Serial.println("(bottom left)");
        }
      }

      if(x < width1-1)
      {
        if(getPixelColor(x+1, y+1) > 0)
        {
          alive+=1;
          //Serial.println("(bottom right)");
        }
      }
    }
    god_Conway(x, y, alive);
  }
}

void god_Conway(int x, int y, int a)
{
  int born[]={3};
  int survive[]={2, 3};
  int kill=0;
  bool birth1=0;
  int living=getPixelColor(x, y);

  if(living > 0)
  {
    if (a == 2 || a == 3)
    {
      kill=1;
    }
  else
  {
    kill=-1;
  }    
  }
  else
  {
    if (a == 3)
    {
      birth1=1;
    }
  }


  if (kill == -1 || birth1 == 1)
  {
    for(int c=0;c<width1;c++)
    {
      if(row0[c]==-1)
      {
        row0[c]=x;
        if(c,width1)
        {
          row0[c+1]=-1;
        }
        break;
      }
    }
  }
  if(kill == 1 || birth1 == 0)
  {
    same++;
  }
}

This code checks around each pixel in a row and discovers how many pixels are on around a certain pixel. getPixelColor(x, y) is code I found for the matrix the reads the pixel's color and return a number greater than 0 if on. The check function takes about 29-30ms per row. Every millisecond counts.

I've tried a big if for just the non-edge pixels. getPixelColor(x, y) does not always return same number so dividing it by expected return number is not always accurate. I made a function to return 1 and 0 automatically then do alive+=That_function(x, y); but it slowed it down.

It only writes down the y of the pixels that needs changing on row0. The code that prints this stops when there is a -1.

Don't use the time consuming function getPixelColor to read the pixels from the display. Instead maintain the board in memory, e. g. static char board[64][64];, and keep a copy of the previous generation also in memory. If there is no library function to display the whole image at once, you need at least to call the presumed setPixelColor function only for the changed pixels.
You might even use a static char board[66][66]; with the image indexes 1..64 and spare yourself the edge considerations.