import sys
input = sys.stdin.readline

n, m = map(int, input().split())

dp = [[[[0 for _ in range(2)] for _ in range(2)] for _ in range(445)] for _ in range(445)]
rep_ = list(range(445))
siz_ = [1]*445
is_path = [False]*445
sides = [0]*445

def fint(v):
    if rep_[v] == v:
        return v
    rep_[v] = fint(rep_[v])
    return rep_[v]

def onion(a, b):
    a = fint(a)
    b = fint(b)
    if a == b:
        return
    siz_[b] += siz_[a]
    rep_[a] = b
    is_path[b] = is_path[b] or is_path[a]

for i in range(n * m):
    rep_[i] = i
    siz_[i] = 1

# vízszintes élek
for i in range(n + 1):
    line = input().strip()
    for j in range(m):
        z = line[j]
        if z == '1':
            if i != n:
                sides[i * m + j] += 1
            if i != 0:
                sides[(i - 1) * m + j] += 1
        else:
            if 0 < i < n:
                onion(i * m + j, (i - 1) * m + j)
            if i == 0:
                is_path[fint(i * m + j)] = True
            if i == n:
                is_path[fint((i - 1) * m + j)] = True

# függőleges élek
for i in range(n):
    line = input().strip()
    for j in range(m + 1):
        z = line[j]
        if z == '1':
            if j != m:
                sides[i * m + j] += 1
            if j != 0:
                sides[i * m + j - 1] += 1
        else:
            if 0 < j < m:
                onion(i * m + j, i * m + j - 1)
            if j == 0:
                is_path[fint(i * m + j)] = True
            if j == m:
                is_path[fint(i * m + j - 1)] = True

paths = []
cycles = []

for i in range(n * m):
    r = fint(i)
    if r == i and sides[i] != 4:
        if is_path[i]:
            paths.append(siz_[i])
        else:
            cycles.append(siz_[i])

paths.sort()
cycles.sort()

ps = len(paths)
cs = len(cycles)

for p in reversed(range(ps + 1)):
    for c in reversed(range(cs + 1)):
        if p == ps and c == cs:
            continue
        dp[p][c][0][0] = -int(1e5)
        dp[p][c][0][1] = -int(1e5)
        dp[p][c][1][0] = int(1e5)
        dp[p][c][1][1] = int(1e5)

        if p < ps:
            if p == ps - 1 and c == cs:
                dp[p][c][0][0] = paths[p]
            if p + 1 < ps:
                dp[p][c][0][0] = max(dp[p][c][0][0], dp[p + 1][c][1][0] + paths[p])
            if c < cs:
                dp[p][c][0][0] = max(dp[p][c][0][0], dp[p + 1][c][1][1] + paths[p])
            if paths[p] > 2:
                w2 = int(1e5)
                if p + 1 < ps:
                    w2 = min(w2, dp[p + 1][c][0][0])
                if c < cs:
                    w2 = min(w2, dp[p + 1][c][0][1])
                if w2 != int(1e5):
                    dp[p][c][0][0] = max(dp[p][c][0][0], w2 + paths[p] - 4)

            # 1 0
            if p == ps - 1 and c == cs:
                dp[p][c][1][0] = -paths[p]
            if p + 1 < ps:
                dp[p][c][1][0] = min(dp[p][c][1][0], dp[p + 1][c][0][0] - paths[p])
            if c < cs:
                dp[p][c][1][0] = min(dp[p][c][1][0], dp[p + 1][c][0][1] - paths[p])
            if paths[p] > 2:
                w2 = -int(1e5)
                if p + 1 < ps:
                    w2 = max(w2, dp[p + 1][c][1][0])
                if c < cs:
                    w2 = max(w2, dp[p + 1][c][1][1])
                if w2 != -int(1e5):
                    dp[p][c][1][0] = min(dp[p][c][1][0], w2 - paths[p] + 4)

        if c < cs:
            if c == cs - 1 and p == ps:
                dp[p][c][0][1] = cycles[c]
            if p < ps:
                dp[p][c][0][1] = max(dp[p][c][0][1], dp[p][c + 1][1][0] + cycles[c])
            if c + 1 < cs:
                dp[p][c][0][1] = max(dp[p][c][0][1], dp[p][c + 1][1][1] + cycles[c])
            w2 = int(2e5)
            if p < ps:
                w2 = min(w2, dp[p][c + 1][0][0])
            if c + 1 < cs:
                w2 = min(w2, dp[p][c + 1][0][1])
            if w2 != int(2e5):
                dp[p][c][0][1] = max(dp[p][c][0][1], w2 + cycles[c] - 8)

            if c == cs - 1 and p == ps:
                dp[p][c][1][1] = -cycles[c]
            if p < ps:
                dp[p][c][1][1] = min(dp[p][c][1][1], dp[p][c + 1][0][0] - cycles[c])
            if c + 1 < cs:
                dp[p][c][1][1] = min(dp[p][c][1][1], dp[p][c + 1][0][1] - cycles[c])
            w2 = -int(2e5)
            if p < ps:
                w2 = max(w2, dp[p][c + 1][1][0])
            if c + 1 < cs:
                w2 = max(w2, dp[p][c + 1][1][1])
            if w2 != -int(2e5):
                dp[p][c][1][1] = min(dp[p][c][1][1], w2 - cycles[c] + 8)

if ps == 0 and cs == 0:
    print(0)
else:
    res = max(dp[0][0][1][0] if ps != 0 else -int(2e5),
              dp[0][0][1][1] if cs != 0 else -int(2e5))
    print(res)