Problem: The maps in the game are divided into square cells called Geo Panels. Some of these panels are painted. We shall assume that the Geo Panels without color are painted the transparent color. 

Besides, the map has so-called Geo Symbols. They look like pyramids of different colors (including Geo Symbols of the transparent color). Each Geo Symbol is located on one Geo Panel, and each Geo Panel may contain no more than one Geo Symbol. 

Geo Symbols can be eliminated. To understand better what happens when a Geo Symbol is eliminated, let us introduce some queue to which we will put the recently eliminated Geo Symbols. 

Let's put at the head of the queue a Geo Symbol that was eliminated just now. Next, we will repeat the following operation: 

Extract the Geo Symbol from the queue. Look at the color of the panel containing the given Geo Symbol. If it differs from transparent and differs from the color of the Geo Symbol, then all Geo Panels of this color are repainted in the color of the given Geo Symbol (transparent Geo Symbols repaint the Geo Panels transparent). Repainting is executed in an infinite spiral strictly in the following order starting from the panel, which contained the Geo Symbol: 

<image>

In other words, we select all the panels that need to be repainted and find their numbers in the infinite spiral whose center is placed in the position of the given Geo Symbol. After that, we repaint them in the order of the number's increasing. 

If a panel contains another Geo Symbol and this panel is being repainted, then the Geo Symbol is removed from the field and placed at the tail of the queue. 

After repainting the Geo Symbol is completely eliminated and the next Geo Symbol is taken from the head of the queue (if there is any) and the process repeats. The process ends if the queue is empty. 

See the sample analysis for better understanding. 

You know the colors of all the Geo Panels and the location of all the Geo Symbols. Determine the number of repaintings, which will occur if you destroy one of the Geo Symbols.

Input

The first line contains two integers n and m (1 ≤ n, m ≤ 300) — the height and the width of the map (in cells).

Then follow n line; each of them contains m numbers — the Geo Panels' colors.

Then follow n more lines; each of them contains m numbers — the Geo Symbols' description. -1 means that the given position contains no Geo Symbol. Otherwise, the number represents the color of the Geo Symbol in the given position.

All colors are integers from 0 to 109. 0 represents the transparent color.

The last line contains two integers x and y (1 ≤ x ≤ n, 1 ≤ y ≤ m) — the row and the column where the Geo Symbol is placed that needs to be eliminated. The rows are numbered from top to bottom, the columns are numbered from left to right. Coordinates are 1-based. It is guaranteed that the position with coordinates (x, y) contains a Geo Symbol.

Output

Print the single number — the total number of repaintings after the Geo Symbol is eliminated. 

Please, do not use the %lld specificator to read or write 64-bit integers in C++. It is preferred to use the cout stream (you may also use the %I64d specificator).

Examples

Input

5 5
9 0 1 1 0
0 0 3 2 0
1 1 1 3 0
1 1 1 3 0
0 1 2 0 3
-1 1 -1 3 -1
-1 -1 -1 0 -1
-1 -1 -1 -1 -1
-1 2 3 -1 -1
-1 -1 -1 -1 2
4 2


Output

35

Note

All actions of the sample you can see on the following picture: 

<image> If your browser does not support APNG and you see just static image, you can see GIF version of this image by the following link:

http://assets.codeforces.com/images/geo_slow.gif

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const int kMaxN = 300, kMaxM = 300;
int n, m, col[kMaxN][kMaxM], mat[kMaxN][kMaxM];
const int kMaxV = kMaxN * kMaxM;
int root[kMaxV], sz[kMaxV], co[kMaxV];
int seq[kMaxN * kMaxM * 2 + 1], idx;
queue<int> q;
int where[kMaxN * kMaxM * 2];
vector<int> on[kMaxN * kMaxM * 2];
int Root(int x) {
  if (x == root[x])
    return x;
  else {
    int t = Root(root[x]);
    co[x] = co[t];
    root[x] = t;
    return t;
  }
}
void Union(int u, int v) {
  sz[u] += sz[v];
  root[v] = u;
  co[v] = co[u];
}
int dis[kMaxN * kMaxM];
bool Cmp(const int &a, const int &b) { return (dis[a] < dis[b]); }
int Calc(int dx, int dy) {
  swap(dx, dy);
  int d = max(abs(dx), abs(dy));
  int res = (2 * d - 1) * (2 * d - 1);
  if (dx == -d && dy == -d) return ((2 * d + 1) * (2 * d + 1));
  if (dy == -d) {
    return (res + (dx - (-(d - 1))) + 1);
  }
  res += d - (-(d - 1));
  if (dx == d) {
    return (res + (dy - (-d) + 1));
  }
  res += d - (-d);
  if (dy == d) {
    return (res + (d - dx + 1));
  }
  res += d - (-d);
  return (res + (d - dy + 1));
}
int main() {
  scanf("%d%d", &n, &m);
  seq[idx++] = 0;
  for (int i = 0; i < n; ++i)
    for (int j = 0; j < m; ++j) {
      scanf("%d", &col[i][j]);
      seq[idx++] = col[i][j];
    }
  for (int i = 0; i < n; ++i)
    for (int j = 0; j < m; ++j) {
      scanf("%d", &mat[i][j]);
      if (mat[i][j] != -1) seq[idx++] = mat[i][j];
    }
  sort(seq, seq + idx);
  idx = unique(seq, seq + idx) - seq;
  for (int i = 0; i < idx; ++i) where[i] = -1;
  for (int i = 0; i < n; ++i)
    for (int j = 0; j < m; ++j) {
      col[i][j] = lower_bound(seq, seq + idx, col[i][j]) - seq;
      root[i * m + j] = i * m + j;
      sz[i * m + j] = 1;
      co[i * m + j] = col[i][j];
      if (where[col[i][j]] == -1)
        where[col[i][j]] = i * m + j;
      else
        Union(where[col[i][j]], i * m + j);
    }
  int x, y;
  scanf("%d%d", &x, &y);
  --x, --y;
  for (int i = 0; i < n; ++i)
    for (int j = 0; j < m; ++j) {
      if (mat[i][j] != -1) {
        mat[i][j] = lower_bound(seq, seq + idx, mat[i][j]) - seq;
        if (i != x || j != y) on[col[i][j]].push_back(i * m + j);
      }
    }
  q.push(x * m + y);
  long long ans = 0;
  while (q.size()) {
    int ux = q.front() / m, uy = q.front() % m;
    q.pop();
    int c = co[Root(ux * m + uy)];
    if (c == 0 || c == mat[ux][uy]) continue;
    if (on[c].size()) {
      int sz = on[c].size();
      for (int i = 0; i < sz; ++i) {
        int v = on[c][i];
        int vx = v / m, vy = v % m;
        dis[v] = Calc(vx - ux, vy - uy);
      }
      sort(on[c].begin(), on[c].end(), Cmp);
      for (int i = 0; i < sz; ++i) q.push(on[c][i]);
      on[c].clear();
    }
    ans += sz[where[c]];
    if (where[mat[ux][uy]] == -1) {
      where[mat[ux][uy]] = where[c];
      co[where[c]] = mat[ux][uy];
      where[c] = -1;
    } else {
      Union(where[mat[ux][uy]], where[c]);
      where[c] = -1;
    }
  }
  printf("%I64d\n", ans);
  return 0;
}