N = int(input())
grid = [input().strip() for _ in range(N)]
R, C = N, 2 * N - 1
copper = sum(line.count("C") for line in grid)


def center_out_indices(n):
    mid = n // 2
    yield mid
    for offset in range(1, n):
        left, right = mid - offset, mid + offset
        if left >= 0:
            yield left
        if right < n:
            yield right

def pyramidal(R, C):
    start = (R - 1, C // 2)
    sr, sc = start
    yield start  # distance 0 first

    for d in range(1, R + 1):
        for dr in range(-d, d + 1):
            dc = d - abs(dr)
            for sign in (-1, 1) if dc != 0 else (1,):
                r = sr + dr
                c = sc + sign * dc
                if 0 <= r < R and 0 <= c < C:
                    yield (r, c)



orders = {
    'row-major': [(r, c) for r in range(R) for c in range(C)],
    'row-major-flipped': [(r, c) for r in reversed(range(R)) for c in range(C)],
    'column-major': [(r, c) for c in range(C) for r in range(R)],
    "column-major-flipped": [(r, c) for c in range(C) for r in reversed(range(R))],
    "diagonal": [
        (r, c)
        for s in range(R + C - 1)  # s = r + c
        for r in range(max(0, s - (C - 1)), min(R - 1, s) + 1)
        for c in [s - r]
    ],
     "diagonal-flipped": [
        (r, c)
        for s in range(R + C - 1)
        for r in reversed(range(max(0, s - (C - 1)), min(R - 1, s) + 1))
        for c in [s - r]
     ],
     "column-center-out": [
         (r, c)
         for c in center_out_indices(C)
         for r in range(R)
         ],
     "column-center-out-flipped": [
        (r, c)
        for c in center_out_indices(C)
        for r in reversed(range(R))
        ],
    "row-major-column-center-out": [
        (r, c) for r in range(R) for c in center_out_indices(C)
    ],
     "row-major-flipped-column-center-out": [
        (r, c)
        for r in reversed(range(R))
        for c in center_out_indices(C)
        ],
     "pyramidal": list(pyramidal(R, C))
}


def num_components(packing, tribe):
    parent, rank = {}, {}

    def find(t):
        if t not in parent:
            parent[t] = t
            rank[t] = 0
        root = t
        while parent[root] != root:
            root = parent[root]
        # Path compression
        while t != root:
            parent[t], t = root, parent[t]
        return root

    def union(s, t):
        ps, pt = find(s), find(t)
        if ps == pt:
            return
        if rank[ps] < rank[pt]:
            parent[ps] = pt
        elif rank[ps] > rank[pt]:
            parent[pt] = ps
        else:
            parent[pt] = ps
            rank[ps] += 1

    for r in range(R):
        for c in range(C):
            if packing[r][c] == tribe:
                parent[(r, c)] = (r, c)
                rank[(r, c)] = 0

    for r in range(R):
        for c in range(C):
            if packing[r][c] != tribe:
                continue
            if r < R - 1 and packing[r + 1][c] == tribe:
                union((r, c), (r + 1, c))
            if c < C - 1 and packing[r][c + 1] == tribe:
                union((r, c), (r, c + 1))

    return len({find(cell) for cell in parent})


def try_order(order):
    solution = [["?"] * C for _ in range(R)]
    tribe = "A"
    total = {"A": 0, "B": 0}
    for r, c in order:
        if grid[r][c] == "#":
            solution[r][c] = "#"
        else:
            solution[r][c] = tribe
            if grid[r][c] == "C":
                total[tribe] += 1
                if total["A"] >= copper // 2:
                    tribe = "B"

    return (
        solution
        if num_components(solution, "A") == num_components(solution, "B") == 1
        and total["A"] == total["B"]
        else None
    )


ok= False
res = ""
for name, o in orders.items():
    solution = try_order(o)
    if solution is not None:
        res += "\033[32mY\033[0m "
        ok = True
    #    for line in solution:
    #        print("".join(line))
    #    break
    else:
        res += "\033[31mN\033[0m "
if ok:
    print(res)
else:
    print()