# Date [ 2020-08-22 21:07:07 ]

# Problem [ d.py ]

# Author Koki_tkg



import sys;      from decimal import Decimal

import math;     from itertools import combinations, product

import bisect;   from collections import Counter, deque, defaultdict



# sys.setrecursionlimit(10 ** 6)

MOD = 10 ** 9 + 7

INF = 10 ** 9

PI = 3.14159265358979323846



def read_str():      return sys.stdin.readline().strip()

def read_int():      return int(sys.stdin.readline().strip())

def read_ints():     return list(map(int, sys.stdin.readline().strip().split()))

def read_str_list(): return list(sys.stdin.readline().strip().split())

def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))

def lcm(a: int, b: int) -> int: return (a * b) // math.gcd(a, b)



import numpy as np

from numba import i8, njit, u1, b1

from heapq import heappop, heappush



@njit(i8(b1[:,:], i8, i8, i8, i8), cache=True)

def solve(grid, ch, cw, dh, dw):

    h, w = grid.shape

    

    dist = np.full((h, w), INF, dtype=np.int64)

    dist[ch][cw] = 0



    que = [(0, ch, cw)]



    while que:

        cnt, y, x = heappop(que)



        if y == dh and x == dw:

            break



        for dy in range(-2, 3):

            for dx in range(-2, 3):

                if dx == 0 and dy == 0:

                    continue



                if abs(dx) == 2 or abs(dy) == 2 or (abs(dx) == 1 and abs(dy) == 1):

                    warp = 1

                else:

                    warp = 0



                nx, ny = x + dx, y + dy

                if nx < 0 or nx >= w or ny < 0 or ny >= h or grid[ny][nx]:

                    continue

                

                if dist[ny][nx] > cnt + warp:

                    dist[ny][nx] = cnt + warp

                    heappush(que, (cnt + warp, ny, nx))



    if dist[dh][dw] == INF:

        return - 1

    else:

        return dist[dh][dw]





def Main():

    H, W = read_ints()

    ch, cw = read_ints(); ch -= 1; cw -= 1

    dh, dw = read_ints(); dh -= 1; dw -= 1



    grid = np.array([[g == '#' for g in read_str()] for _ in range(H)])

    

    print((solve(grid, ch, cw, dh, dw)))



def cc_export(config):

    from numba.pycc import CC

    cc = CC('my_module')

    for func, signature in config:

        vars()[func.__name__] = njit(signature)(func)

        cc.export(func.__name__, signature)(func)

    cc.compile()



if __name__ == '__main__':

    Main()

# Date [ 2020-08-22 21:07:07 ]

# Problem [ d.py ]

# Author Koki_tkg



import sys;      from decimal import Decimal

import math;     from itertools import combinations, product

import bisect;   from collections import Counter, deque, defaultdict



# sys.setrecursionlimit(10 ** 6)

MOD = 10 ** 9 + 7

INF = 10 ** 9

PI = 3.14159265358979323846



def read_str():      return sys.stdin.readline().strip()

def read_int():      return int(sys.stdin.readline().strip())

def read_ints():     return list(map(int, sys.stdin.readline().strip().split()))

def read_str_list(): return list(sys.stdin.readline().strip().split())

def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))

def lcm(a: int, b: int) -> int: return (a * b) // math.gcd(a, b)



import numpy as np

from numba import i8, njit, u1, b1

from heapq import heappop, heappush



#@njit(i8(b1[:,:], i8, i8, i8, i8), cache=True)

def solve(grid, ch, cw, dh, dw):

    h, w = grid.shape

    

    dist = np.full((h, w), INF, dtype=np.int64)

    dist[ch][cw] = 0



    que = [(0, ch, cw)]



    while que:

        cnt, y, x = heappop(que)



        if y == dh and x == dw:

            break



        for dy in range(-2, 3):

            for dx in range(-2, 3):

                if dx == 0 and dy == 0:

                    continue



                if abs(dx) == 2 or abs(dy) == 2 or (abs(dx) == 1 and abs(dy) == 1):

                    warp = 1

                else:

                    warp = 0



                nx, ny = x + dx, y + dy

                if nx < 0 or nx >= w or ny < 0 or ny >= h or grid[ny][nx]:

                    continue

                

                if dist[ny][nx] > cnt + warp:

                    dist[ny][nx] = cnt + warp

                    heappush(que, (cnt + warp, ny, nx))



    if dist[dh][dw] == INF:

        return - 1

    else:

        return dist[dh][dw]





def Main():

    H, W = read_ints()

    ch, cw = read_ints(); ch -= 1; cw -= 1

    dh, dw = read_ints(); dh -= 1; dw -= 1



    grid = np.array([[g == '#' for g in read_str()] for _ in range(H)])

    

    print((solve(grid, ch, cw, dh, dw)))



def cc_export():

    from numba.pycc import CC

    cc = CC('my_module')

    cc.export('solve','(b1[:,:], i8, i8, i8, i8,)')(solve)

    cc.compile()



if __name__ == '__main__':

    if sys.argv[-1] == 'ONLINE_JUDGE':

        cc_export()

        exit()

    from my_module import solve

    Main()

# Date [ 2020-08-22 21:07:07 ]
# Problem [ d.py ]
# Author Koki_tkg
import sys
from decimal import Decimal
import math
from itertools import combinations, product
import bisect
from collections import Counter, deque, defaultdict

# sys.setrecursionlimit(10 ** 6)
MOD = 10**9 + 7
INF = 10**9
PI = 3.14159265358979323846


def read_str():
    return sys.stdin.readline().strip()


def read_int():
    return int(sys.stdin.readline().strip())


def read_ints():
    return list(map(int, sys.stdin.readline().strip().split()))


def read_str_list():
    return list(sys.stdin.readline().strip().split())


def read_int_list():
    return list(map(int, sys.stdin.readline().strip().split()))


def lcm(a: int, b: int) -> int:
    return (a * b) // math.gcd(a, b)


import numpy as np
from numba import i8, njit, u1, b1
from heapq import heappop, heappush


@njit(i8(b1[:, :], i8, i8, i8, i8), cache=True)
def solve(grid, ch, cw, dh, dw):
    h, w = grid.shape
    dist = np.full((h, w), INF, dtype=np.int64)
    dist[ch][cw] = 0
    que = [(0, ch, cw)]
    while que:
        cnt, y, x = heappop(que)
        if y == dh and x == dw:
            break
        for dy in range(-2, 3):
            for dx in range(-2, 3):
                if dx == 0 and dy == 0:
                    continue
                if abs(dx) == 2 or abs(dy) == 2 or (abs(dx) == 1 and abs(dy) == 1):
                    warp = 1
                else:
                    warp = 0
                nx, ny = x + dx, y + dy
                if nx < 0 or nx >= w or ny < 0 or ny >= h or grid[ny][nx]:
                    continue
                if dist[ny][nx] > cnt + warp:
                    dist[ny][nx] = cnt + warp
                    heappush(que, (cnt + warp, ny, nx))
    if dist[dh][dw] == INF:
        return -1
    else:
        return dist[dh][dw]


def Main():
    H, W = read_ints()
    ch, cw = read_ints()
    ch -= 1
    cw -= 1
    dh, dw = read_ints()
    dh -= 1
    dw -= 1
    grid = np.array([[g == "#" for g in read_str()] for _ in range(H)])
    print((solve(grid, ch, cw, dh, dw)))


def cc_export(config):
    from numba.pycc import CC

    cc = CC("my_module")
    for func, signature in config:
        vars()[func.__name__] = njit(signature)(func)
        cc.export(func.__name__, signature)(func)
    cc.compile()


if __name__ == "__main__":
    Main()

# Date [ 2020-08-22 21:07:07 ]
# Problem [ d.py ]
# Author Koki_tkg
import sys
from decimal import Decimal
import math
from itertools import combinations, product
import bisect
from collections import Counter, deque, defaultdict

# sys.setrecursionlimit(10 ** 6)
MOD = 10**9 + 7
INF = 10**9
PI = 3.14159265358979323846


def read_str():
    return sys.stdin.readline().strip()


def read_int():
    return int(sys.stdin.readline().strip())


def read_ints():
    return list(map(int, sys.stdin.readline().strip().split()))


def read_str_list():
    return list(sys.stdin.readline().strip().split())


def read_int_list():
    return list(map(int, sys.stdin.readline().strip().split()))


def lcm(a: int, b: int) -> int:
    return (a * b) // math.gcd(a, b)


import numpy as np
from numba import i8, njit, u1, b1
from heapq import heappop, heappush

# @njit(i8(b1[:,:], i8, i8, i8, i8), cache=True)
def solve(grid, ch, cw, dh, dw):
    h, w = grid.shape
    dist = np.full((h, w), INF, dtype=np.int64)
    dist[ch][cw] = 0
    que = [(0, ch, cw)]
    while que:
        cnt, y, x = heappop(que)
        if y == dh and x == dw:
            break
        for dy in range(-2, 3):
            for dx in range(-2, 3):
                if dx == 0 and dy == 0:
                    continue
                if abs(dx) == 2 or abs(dy) == 2 or (abs(dx) == 1 and abs(dy) == 1):
                    warp = 1
                else:
                    warp = 0
                nx, ny = x + dx, y + dy
                if nx < 0 or nx >= w or ny < 0 or ny >= h or grid[ny][nx]:
                    continue
                if dist[ny][nx] > cnt + warp:
                    dist[ny][nx] = cnt + warp
                    heappush(que, (cnt + warp, ny, nx))
    if dist[dh][dw] == INF:
        return -1
    else:
        return dist[dh][dw]


def Main():
    H, W = read_ints()
    ch, cw = read_ints()
    ch -= 1
    cw -= 1
    dh, dw = read_ints()
    dh -= 1
    dw -= 1
    grid = np.array([[g == "#" for g in read_str()] for _ in range(H)])
    print((solve(grid, ch, cw, dh, dw)))


def cc_export():
    from numba.pycc import CC

    cc = CC("my_module")
    cc.export("solve", "(b1[:,:], i8, i8, i8, i8,)")(solve)
    cc.compile()


if __name__ == "__main__":
    if sys.argv[-1] == "ONLINE_JUDGE":
        cc_export()
        exit()
    from my_module import solve

    Main()

- -@njit(i8(b1[:, :], i8, i8, i8, i8), cache=True) +# @njit(i8(b1[:,:], i8, i8, i8, i8), cache=True) -def cc_export(config): +def cc_export(): -    for func, signature in config: -        vars()[func.__name__] = njit(signature)(func) -        cc.export(func.__name__, signature)(func) +    cc.export("solve", "(b1[:,:], i8, i8, i8, i8,)")(solve) +    if sys.argv[-1] == "ONLINE_JUDGE": +        cc_export() +        exit() +    from my_module import solve +