import sys, os
from collections import Counter as C
from collections import defaultdict as dd

"""
same convention as SVG
           W
(0,0)┌───────────► x
     │                
  H  │                
     │                
     │                
     ▼                
     y
grid G store list of rows
to get G(x,y), must first extract row y and then col y => G[y][x]
"""

def grid_geom(G):
    H = len(G)
    W = len(G[0])
    return W, H

def in_grid(G, x, y) -> bool:
    W, H = grid_geom(G)
    return x>=0 and x<W and y>=0 and y<H

def get_in_grid(G, x, y):
    if in_grid(W, H, x,y):
        return G[y][x]

UP = (0,-1) ; RIGHT = (1,0) ; DOWN = (0,1) ; LEFT = (-1,0)
M4=[ UP, RIGHT, DOWN, LEFT ]
D4 = [(1,1),(-1,-1),(1,-1),(-1,1)]
M8 = M4 + D4

L = sys.stdin.read().strip().split("\n")
G = [list(l) for l in L]

W, H = grid_geom(G)

# 1: find guard
gx = gy = 0
for i in range(H):  # rows
    for j in range(W):  # cols
        if G[i][j] == '^':
            gx = j
            gy = i

# 2: compute guard's walk
M4N = { M4[i-1]:M4[i] for i in range(len(M4))}
print(f'{M4N=}')
S = 0
V = C()  # visited
T = dd(set)  # each position forcing a turn, grouped by turn type
sens = M4[0]
on = True
while on : # in the map
    V[(gx,gy)] +=1
    (dx,dy) = sens
    gxn = gx + dx
    gyn = gy + dy
    #print(S, sens, dx, dy, gxn, gyn)
    if not in_grid(G, gxn, gyn): # off the map
        on = False
    elif G[gyn][gxn] == '#':  # must turn
        T[sens].add((gxn,gyn))
        sens = M4N[sens]
    else:  # move
        gx = gxn
        gy = gyn
        S += 1
print(S, len(V))

for (x,y) in V.keys():
    G[y][x] = "o"
for row in G:
    #print(" ".join(row))
    pass

M = 0
for m, v in T.items():
    (dx,dy) = m
    for (x,y) in v:
        print(f"{dx},{dy}:for", (x,y))
        # find a position for nearest next turn
        n = None
        (dxn, dyn) = M4N[m]
        for i in range(1,10):
            cn = (x-dx+i*dxn,y-dy+i*dyn)
            #print(f'{cn=}')
            if cn in T[M4N[m]]:
                n = cn
                print("  found n", n)
                break
        if n:
            (xn,yn) = n
            (dxp, dyp) = M4N[M4N[m]]
            p = None
            print(f"    lookfor p {dxp=},{dyp=}")
            for i in range(1,10):
                cp = (xn-dxn+i*dxp,yn-dyn+i*dyp)
                #print(f'{cp=}')
                if cp in T[M4N[M4N[m]]]:
                    p = cp
                    print("    found p", p)
                    break
            if p:
                print((x,y),n,p)
                M+=1
   # break
print(M)