### BUGGY CODE ###

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

h, w = map(int, input().split())
ch, cw = map(int, input().split())
dh, dw = map(int, input().split())
graph = [0] + [0] * h
inverse = [0] + [0] * h
for i in range(h):
    graph[i + 1] = [0] + list(input().strip())
    inverse[i + 1] = [0] + [-1] * w

from collections import deque

def bfs(graph, queue, inverse, part_seq):
    part = set()
    while queue:
        current_h, current_w = queue.popleft()
        part.add((current_h, current_w))
        inverse[current_h][current_w] = part_seq

        for dh, dw in ((-1, 0), (1, 0), (0, -1), (0, 1)):
            next_h, next_w = current_h + dh, current_w + dw
            if not ((1 <= next_h <= h) and (1 <= next_w <= w)):
                continue
            if graph[next_h][next_w] == '#':
                continue
            if inverse[next_h][next_w] != -1:
                continue
            queue.append((next_h, next_w))
    return part

part_seq = 0
parts = dict()
start_part = None
end_part = None
for i in range(1, h+1):
    for j in range(1, w+1):
        if graph[i][j] == '#':
            continue
        if inverse[i][j] != -1:
            continue
        else:
            part_seq += 1
            queue = deque([(i, j)])
            part = bfs(graph, queue, inverse, part_seq)
            parts[part_seq] = part
            if (ch, cw) in part:
                start_part = part_seq
            if (dh, dw) in part:
                end_part = part_seq

if start_part == end_part:
    print(0)
    sys.exit(0)

def can_warp(start_part, next_part):
    for current_h, current_w in parts[start_part]:
        for dh in range(-2, 3):
            for dw in range(-2, 3):
                if dh == 0 and dw == 0:
                    continue
                next_h, next_w = current_h + dh, current_w + dw
                if not ((1 <= next_h <= h) and (1 <= next_w <= w)):
                    continue
                if graph[next_h][next_w] == '#':
                    continue
                if inverse[next_h][next_w] == -1:
                    continue
                if inverse[next_h][next_w] == next_part:
                    return True
    return False

new_graph = [0] + [[] for _ in range(part_seq)]
for i in range(1, part_seq+1):
    for j in range(i + 1, part_seq+1):
        if can_warp(i, j):
            new_graph[i].append(j)
            new_graph[j].append(i)

dist = [0] + [-1] * part_seq
dist[start_part] = 0
queue = deque([start_part])
while queue:
    current = queue.popleft()

    for n in new_graph[current]:
        if dist[n] != -1:
            continue
        else:
            dist[n] = dist[current] + 1
            queue.append(n)

if dist[end_part] != -1:
    print(dist[end_part])
else:
    print(-1)

### FIXED CODE ###

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

h, w = map(int, input().split())
ch, cw = map(int, input().split())
dh, dw = map(int, input().split())
graph = [0] + [0] * h
dist = [0] + [0] * h
for i in range(h):
    graph[i + 1] = [0] + list(input().strip())
    dist[i + 1] = [0] + [-1] * w

from collections import deque

def can_move(graph, dist, next_h, next_w):
    if not ((1 <= next_h <= h) and (1 <= next_w <= w)):
        return False
    if graph[next_h][next_w] == '#':
        return False
    return True

# FYI: https://betrue12.hateblo.jp/entry/2018/12/08/000020
def bfs(graph, queue, dist):
    part = set()
    while queue:
        current_h, current_w = queue.popleft()

        # cost 0
        for dh, dw in ((-1, 0), (1, 0), (0, -1), (0, 1)):
            next_h, next_w = current_h + dh, current_w + dw
            if not can_move(graph, dist, next_h, next_w):
                continue
            # https://atcoder.jp/contests/abc176/editorial/65
            # 解説のとおり、先にワープして到達している場合でも短くなるのであれば上書きする
            # Dijkstraみたいに考える
            if dist[next_h][next_w] == -1 or dist[next_h][next_w] > dist[current_h][current_w]:
                dist[next_h][next_w] = dist[current_h][current_w]
                queue.appendleft((next_h, next_w))

        # cost 1
        for dh in range(-2, 3):
            for dw in range(-2, 3):
                next_h, next_w = current_h + dh, current_w + dw
                if not can_move(graph, dist, next_h, next_w):
                    continue
                if dist[next_h][next_w] != -1:
                    continue
                dist[next_h][next_w] = dist[current_h][current_w] + 1
                queue.append((next_h, next_w))

queue = deque([(ch, cw)])
dist[ch][cw] = 0
bfs(graph, queue, dist)
print(dist[dh][dw])