#include <bits/extc++.h>
using namespace std;

typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
#define vt vector
#define pii pair<int, int>
#define pb push_back
#define umap unordered_map
#define uset unordered_set
#define all(x) begin(x), end(x)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define contains(l, a) l.find(a) != l.end()
#define DEBUG 1
#define dbg(x) \
    if (DEBUG) { cout << #x << " = " << x << endl; }
#define dbgv(x) \
    if (DEBUG) { \
        cout << #x << " = "; \
        for (auto _i : x) cout << _i << " "; \
        cout << endl; \
    }
#define dbgm(x, n, m) \
    if (DEBUG) { \
        cout << #x << " = " << endl; \
        FOR(_i, 0, n) { \
            FOR(_j, 0, m) cout << x[_i][_j] << " "; \
            cout << endl; \
        } \
    }

typedef int T;
struct pt {
    T x, y;
    pt(T x = 0, T y = 0) : x(x), y(y) {}
};

bool segInt(pt p1, pt p2, pt p3, pt p4) {
  int d1 = (p4.y - p3.y) * (p1.x - p3.x) + (p3.x - p4.x) * (p1.y - p3.y);
  int d2 = (p4.y - p3.y) * (p2.x - p3.x) + (p3.x - p4.x) * (p2.y - p3.y);
  int d3 = (p2.y - p1.y) * (p3.x - p1.x) + (p1.x - p2.x) * (p3.y - p1.y);
  int d4 = (p2.y - p1.y) * (p4.x - p1.x) + (p1.x - p2.x) * (p4.y - p1.y);
  return ((d1 > 0 && d2 < 0) || (d1 < 0 && d2 > 0)) &&
  ((d3 > 0 && d4 < 0) || (d3 < 0 && d4 > 0));
}

int main() {
  cout.precision(10);
  int W, H, Sx, Sy, Ex, Ey; cin >> W >> H >> Sx >> Sy >> Ex >> Ey;

  ld hor = sqrtl((Sx - Ex)*(Sx - Ex) + (Sy - Ey)*(Sy - Ey));

  H /= 2;
  W /= 2;

  vt<vi> grid(H, vi(W));
  FOR(i, 0, H) FOR (j, 0, W) cin >> grid[i][j];

  int Dx = abs(Ex-Sx);
  int Dy = abs(Ey-Sy);

  pt s(Sx, Sy), e(Ex, Ey);

  int vert = 0;
  int current_height = grid[Sy/2][Sx/2];

  int grid_x = Sx/2;
  int grid_y = Sy/2;
  int grid_dx = (Ex > Sx) - (Sx > Ex);
  int grid_dy = (Ey > Sy) - (Sy > Ey);


  if (Dx > Dy) {
    int dx = (Ex > Sx) - (Sx > Ex);
    int dy = 2*((Ey > Sy) - (Sy > Ey));
    int y = Sy-dy/2;
    for (int x = Sx; x != Ex; x+=dx) {
      if (x%2) continue;
      bool int1 = segInt(s, e, pt(x, y), pt(x, y+dy));
      bool int2 = segInt(s, e, pt(x, y+dy), pt(x, y+2*dy));

      int h1 = grid[grid_y][grid_x+grid_dx];
      int h2 = grid[grid_y+grid_dy][grid_x+grid_dx];
      int h3 = grid[grid_y+grid_dy][grid_x];

      if (!int1 && !int2) {
        // first move up (to Q)
        vi temp = {h1, h2, h3};
        sort(all(temp));
        if (temp[1] > current_height) {
          vert += abs(current_height - temp[1]);
          current_height = temp[1];
        }

        // Now move down
        vert += abs(current_height - h2);
        current_height = h2;

        y += dy;
        grid_y += grid_dy;
      } else if (int1) {
        vert += abs(current_height - h1);
        current_height = h1;
      } else {
        vert += abs(current_height - h3);
        current_height = h3;
        y += dy;
        grid_y += grid_dy;
      }
      grid_x += grid_dx;
    }
  } else {
    int dy = (Ey > Sy) - (Sy > Ey);
    int dx = 2*((Ex > Sx) - (Sx > Ex));
    int x = Sx-dx/2;
    for (int y = Sy; y != Ey; y+=dy) {
      if (y%2) continue;
      bool int1 = segInt(s, e, pt(x, y), pt(x+dx, y));
      bool int2 = segInt(s, e, pt(x+dx, y), pt(x+2*dx, y));
      int h1 = grid[grid_y+grid_dy][grid_x];
      int h2 = grid[grid_y+grid_dy][grid_x+grid_dx];
      int h3 = grid[grid_y][grid_x+grid_dx];

      if (!int1 && !int2) {
        // first move up (to Q)
        vi temp = {h1, h2, h3};
        sort(all(temp));
        if (temp[1] > current_height) {
          vert += abs(current_height - temp[1]);
          current_height = temp[1];
        }

        // Now move down
        vert += abs(current_height - h2);
        current_height = h2;

        x += dx;
        grid_x += grid_dx;
      } else if (int1) {
        vert += abs(current_height - h1);
        current_height = h1;
      } else {
        vert += abs(current_height - h3);
        current_height = h3;
        x += dx;
        grid_x += grid_dx;
      }
      grid_y += grid_dy;
    }
  }
  cout << hor + vert << endl;



}