using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Windows;
using System.Collections;

namespace Flies
{

    class Dec<T> : IEnumerable<T>
    {
        class DecItem<T>
        {
            public T value;
            public DecItem<T> next;
            public DecItem<T> previous;
        }

        DecItem<T> last;
        DecItem<T> first;

        public void PushInTheEnd(T arg)
        {
            var newitem = new DecItem<T> { value = arg, previous = last };
            if (last != null)
                last.next = newitem;
            else
                first = newitem;
            last = newitem;

        }

        public void PushInTheStart(T arg)
        {
            var newitem = new DecItem<T> { value = arg, next = first };
            if (first != null)
                first.previous = newitem;
            else
                last = newitem;
            first = newitem;
        }

        public T Pop()
        {
            if (first == null) throw new Exception("");
            var result = first.value;
            first = first.next;
            if (first == null)
                last = null;
            return result;
        }

        public bool IsEmpty()
        {
            return first == null;
        }

        public IEnumerator<T> GetEnumerator()
        {
            var item = first;
            while (item != null)
            {
                yield return item.value;
                item = item.next;
            }
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }

    public class Answer
    {
        public int countOfSteps;
        public int countOfChangeBoots;
    }

    public class PathFinder
    {

        static Point[] Neighbours = new Point[] { new Point(0, 1), new Point(0, -1), new Point(1, 0), new Point(-1, 0), new Point(1, 1), new Point(-1, -1), new Point(-1, 1), new Point(1, -1) };

        private static IEnumerable<Point> GetNeighbours(Point from, int[,] map, PointAndCount[,] boolMap)
        {
            return Neighbours.Select(x => new Point(from.X + x.X, from.Y + x.Y))
                .Where(x => CanMove(x.X, x.Y, map, boolMap))
                .ToArray();
        }

        static bool CanMove(int x, int y, int[,] map, PointAndCount[,] boolMap)
        {
            return x >= 0 && y >= 0 && x < map.GetLength(0) && y < map.GetLength(1) && map[x, y] != 0;
        }

        public static Answer DFS(Point source, Point target, int[,] map, PointAndCount[,] boolMap)
        {
            var answer = new Answer();
            if (target == source)
            {
                answer.countOfSteps = 1;
                return answer;
            }
            var queue = new Dec<Point>();
            queue.PushInTheEnd(source);
            map[source.X, source.Y] = 0;
            boolMap[source.X, source.Y].Step = 0;
            while (!queue.IsEmpty())
            {
                Point top = queue.Pop();
                foreach (var neighbour in GetNeighbours(top, map, boolMap))
                {
                    if (boolMap[top.X, top.Y].Step + 1 < boolMap[neighbour.X, neighbour.Y].Step ||
                        boolMap[neighbour.X, neighbour.Y].point == new Point(-1, -1))
                    {
                        if (map[neighbour.X, neighbour.Y] == map[top.X, top.Y])
                            queue.PushInTheStart(neighbour);
                        else
                            queue.PushInTheEnd(neighbour);
                        boolMap[neighbour.X, neighbour.Y].Step = boolMap[top.X, top.Y].Step + 1;
                        boolMap[neighbour.X, neighbour.Y].point = top;
                    }
                }
            }
            var currentPoint = target;
            while (boolMap[currentPoint.X, currentPoint.Y].point != source)
            {
                if (boolMap[currentPoint.X, currentPoint.Y].point == new Point(-1, -1))
                    return new Answer();
                answer.countOfSteps++;
                if (map[currentPoint.X, currentPoint.Y] != map[boolMap[currentPoint.X, currentPoint.Y].point.X, boolMap[currentPoint.X, currentPoint.Y].point.Y])
                    answer.countOfChangeBoots++;
                currentPoint = boolMap[currentPoint.X, currentPoint.Y].point;
            }
            answer.countOfSteps += 2;
            return answer;
        }
    }

    public class PointAndCount
    {
        public Point point;
        public int Step;
        public PointAndCount(Point p, int s)
        {
            this.point = p;
            this.Step = s;
        }
    }

    class Program
    {
        public static void Main()
        {
            var temp = Console.ReadLine().Split();
            var M = int.Parse(temp[0]);
            var N = int.Parse(temp[1]);
            temp = Console.ReadLine().Split();
            var computer = new Point(int.Parse(temp[0]) - 1, int.Parse(temp[1]) - 1);
            temp = Console.ReadLine().Split();
            var refreg = new Point(int.Parse(temp[0]) - 1, int.Parse(temp[1]) - 1);
            var map = new int[M, N];
            for (int i = 0; i < M; i++)
            {
                var tempString = Console.ReadLine();
                for (int j = 0; j < N; j++)
                    map[i, j] = int.Parse(tempString[j].ToString());
            }
            var boolMap = new PointAndCount[M, N];
            for (var i = 0; i < boolMap.GetLength(0); i++)
                for (var j = 0; j < boolMap.GetLength(1); j++)
                {
                    boolMap[i, j] = new PointAndCount(new Point(-1, -1), N * M + 1);
                }
            var answer = PathFinder.DFS(computer, refreg, map, boolMap);
            Console.WriteLine("{0} {1}", answer.countOfSteps, answer.countOfChangeBoots);
        }
    }
}