Процесс висит - окна нет

public class LiveMatrix : IEquatable<LiveMatrix>
{
    private readonly  bool [,] matrix;
    public int Rows {get;}
    public int Columns {get;}
 
    private int hashCode = -8305258042;
    public override int GetHashCode() => hashCode;
    public bool Equals(LiveMatrix other)
    {
         if(hashCode != other.hashCode)
               return false;
         if(Rows != other.Rows || Columns != other. Columns)
               return false;
 
         for(int row = 0; row < Rows; row++)
         for(int column = 0; column < Columns; column++)
               if(! matrix [row, column] ^ other.matrix [row, column])
                     return false;
          return true;
     }
 
    public override bool Equals(object other)
    {
        if(other is LiveMatrix oth)
             return Equals (oth);
        return false;
     }
 
    public LiveMatrix(int rows, int columns)
    {
        Rows = rows;
        Columns = columns;
        matrix = new bool [Rows, Columns];
        hashCode ^= Rows.GetHashCode();
        hashCode ^= Columns.GetHashCode();
     }
 
    public bool IsLiveTop {get; private set;}
    public bool IsLiveBottom {get; private set;}
    public bool IsLiveLeft {get; private set;}
    public bool IsLiveRight {get; private set;}
 
     public void SetCell(int row, int column)
     {
           if(matrix [row, column])
               return;
 
           matrix [row, column] = true;
           if (row==0)
               IsLiveTop = true;
           if (column==0)
               IsLiveLeft = true;
           if (row==Rows-1)
               IsLiveBottom = true;
           if (row==Columns-1)
               IsLiveRight = true;
 
          hashCode ^= row.GetHashCode();
          hashCode ^= column.GetHashCode();
        
      }
}

 private int StillAlive(Point check, string newOrOld)
        {
            int i;
            if (newOrOld == "new") i = 0;
            else i = -1;
            foreach (Point p in Gameboard)
            {
                if (p.X > check.X - 2 && p.X < check.X + 2 && p.Y > check.Y - 2 && p.Y < check.Y + 2) i++;
            }
            return i;
        }

private void NewBorn(Point check)
        {
            bool b = true;
            if (Gameboard.FirstOrDefault(p => p.X == check.X && p.Y == check.Y) != null) b = false;
            if (newPoints.FirstOrDefault(p => p.X == check.X && p.Y == check.Y) != null) b = false;
            if (b && StillAlive(check, "new") > 2 ) newPoints.Add(check);
        }

 var arr = new int[100000];
            for (int i = 0; i < arr.Length; i++)
            {
                arr[i] = i;
            }
 
            var sw = new Stopwatch();
            sw.Start();
 
            int a = arr.FirstOrDefault(p => p == 95000);
            Console.WriteLine(sw.Elapsed);
 
            sw.Restart();
 
            for (int i = 0; i < arr.Length; i++)
            {
                if (arr[i] == 95000)
                    break;
            }
            Console.WriteLine(sw.Elapsed);
            Console.ReadLine();

public static bool[,] CheckBorder(bool[,] matrix)
{
    int rows = matrix.GetLength(0)-1;
    int cols = matrix.GetLength(1)-1;
 
    // Определение жизни на краях
    bool isTop = false;
    bool isBottom = false;
    for(int col = 0; col <= cols && !(isTop && isBottom); col++)
    {
        isTop |= matrix[0, col];
        isBottom |= matrix[rows, col];
    }
    bool isLeft = false;
    bool isRight = false;
    for(int row = 0; row <= rows && !(isLeft && isRight); row++)
    {
        isLeft |= matrix[row, 0];
        isRight |= matrix[row, cols];
    }
 
// Если нигде на границах нет жизни, то возврат
// исходной матрицы
     if (!(isTop || isBottom || isLeft || isRight))
              return matrix;
 
    //Параметры расширенной матрицы
     int rowsN = rows + (isTop ? 1 : 0) + (isBottom ? 1 : 0)+1;
     int colsN = cols + (isLeft ? 1 : 0) + (isRight ? 1 : 0)+1;
 
     int rowOffs = isTop ? 1 : 0;
     int colOffs = isLeft ? 1 : 0;
 
// Создание расширенной матрицы 
// и копирование Жизни
     bool [,] matr = new bool [rowsN, colsN];
    for(int row = 0; row <= rows; row++)
    for(int col = 0; col <= cols; col++)
        matr[row+rowOffs, col+colOffs] = matrix [row, col];
 
     
     return matr;
}

public static bool[,] NextStepLive(bool[,] matrix)
{
    int rows = matrix.GetLength(0);
    int cols = matrix.GetLength(1);
 
    // Создание матрицы нового штампа
     bool [,] matr = new bool [rows--, cols--];
 
      // Проверка на создание жизни на краях
       for(int col = 1; col < cols; col++)
       {
             matr[0, col] = matrix[1, col-1]
                                     && matrix[1, col]
                                      && matrix[1, col+1];
             matr[rows, col] = matrix[rows-1, col-1]
                                     && matrix[rows-1, col]
                                      && matrix[rows-1, col+1];
        }
       for(int row = 1; row < rows; row++)
       {
             matr[row, 0] = matrix[row-1, 1]
                                     && matrix[row, 1]
                                      && matrix[row+1,1];
             matr[row, cols] = matrix[row-1, cols-1]
                                     && matrix[row, cols-1]
                                      && matrix[row+1, cols-1];
        }
 
        // Проверка на жизнь в центре матрицы
    for(int row = 1; row < rows-1; row++)
    for(int col = 1; col < cols-1; col++)
    { int count = matrix[row-1, col-1] ? 1 : 0
                       + matrix[row-1, col] ? 1 : 0 
                       + matrix[row-1, col+1] ? 1 : 0 
                       + matrix[row, col-1] ? 1 : 0 
                       + matrix[row, col+1] ? 1 : 0 
                       + matrix[row+1, col-1] ? 1 : 0 
                       + matrix[row+1, col] ? 1 : 0 
                       + matrix[row+1, col+1] ? 1 : 0 ;
      matr[row, col] = count == 3
                                  || (count == 2 && matrix[row, col]);
    }
    return matr;
}