친구

import java.io.*;
import java.util.*;

public class Main {

    public static void main(String[] args) throws Exception {
        final var br = new BufferedReader(new InputStreamReader(System.in));
        final var bw = new BufferedWriter(new OutputStreamWriter(System.out));

        final var n = Integer.parseInt(br.readLine());
        final var solver = new Solver(n);
        for (var i = 0; i < n; i++) {
            final var edges = br.readLine().trim().toCharArray();
            for (var j = 0; j < n; j++) {
                if (edges[j] == 'Y') {
                    solver.addEdge(i, j);
                }
            }
        }

        bw.write(String.valueOf(solver.getMaxConnectionCount()));
        bw.flush();
        bw.close();
        br.close();
    }

    private static class Solver {

        private final boolean[][] graph;
        private final int size;

        private boolean[][] connectedMap;

        private Solver(final int number) {
            size = number;
            graph = new boolean[number][number];
            for (var y = 0; y < number; y++) {
                for (var x = 0; x < number; x++) {
                    graph[y][x] = false;
                }
            }
        }

        private void addEdge(final int start, final int end) {
            graph[start][end] = true;
        }

        private void calculateConnectedMap() {
            connectedMap = new boolean[size][size];
            for (var k = 0; k < size; k++) {
                for (var s = 0; s < size; s++) {
                    for (var e = 0; e < size; e++) {
                        final var isSelfReference = s == e;
                        if (isSelfReference) {
                            continue;
                        }

                        final var isPossibleToConnect = graph[s][e] || (graph[s][k] && graph[k][e]);
                        if (isPossibleToConnect) {
                            connectedMap[s][e] = true;
                        }
                    }
                }
            }
        }

        private int getMaxConnectionCount() {
            if (Objects.isNull(connectedMap)) {
                return 0;
            }
            this.calculateConnectedMap();
            return calculateMaxFriends();
        }

        private int calculateMaxFriends() {
            var maxFriends = Integer.MIN_VALUE;
            for (var y = 0; y < size; y++) {
                var friends = 0;
                for (var x = 0; x < size; x++) {
                    if (connectedMap[y][x]) {
                        friends++;
                    }
                }
                if (maxFriends < friends) {
                    maxFriends = friends;
                }
            }
            return maxFriends;
        }
    }
}