/*
TASK:lab101
LANG:C++
*/

#include <stdio.h>
#include <queue>
#include <vector>

using namespace std;

#define WIN 1
#define LOSE 2
#define TIE 0

#define isUP(i,j) ((i) & (1<<(j-1)))
#define isDOWN(i,j) ((( (i) & (1<<(j-1) ))) ^ (1))

#define FLIP(i,j) ( ((i) ^ (1<<(j-1) ) ) )
#define GET(i,j) ((i) & (1<<(j-1)))

#define X1 ((s.x1)+(dx[i]))
#define Y1 ((s.y1)+(dy[i]))
#define X2 ((s.x2)+(dx[i]))
#define Y2 ((s.y2)+(dy[i]))

#define IN "lab101.in"
#define OUT "lab101.out"

#define MAXSTATES (10*10*10*10*(2<<10))
#define MAXN 16
#define FOR(i,a,b) for(int (i)=(a); (i)<=(b); (i)++)
#define PII pair<int,int>
#define X first
#define Y second
#define mp make_pair
#define pb push_back

int dx[4] = {-1,1,0,0};
int dy[4] = {0,0,-1,1};

typedef struct state {
        int x1,y1,x2,y2,mask;
        state () {x1 = x2 = y1 = y2 = mask = 0;}
        state (int xx1,int yy1,int xx2,int yy2,int mmask) {
              x1 = xx1;
              y1 = yy1;
              x2 = xx2;
              y2 = yy2;
              mask = mmask;
        }
};


int N,M,K;
char valid[MAXSTATES] = {};
char w[MAXSTATES] = {};
char vis[MAXSTATES] = {};
char nnum[MAXSTATES] = {};
int m[MAXN][MAXN] = {};
int h[MAXN][MAXN] = {};
PII r[MAXN] = {};
vector<PII > g[MAXN][MAXN];
queue<int> q;
int Start,endx,endy;

//int t[MAXN][MAXN] = {};


int code (state & s) {
    int ret = s.mask;
    ret = ret*10+s.x1;
    ret = ret*10+s.y1;
    ret = ret*10+s.x2;
    ret = ret*10+s.y2;
    return ret;
}

int decode (int v,state & s) {
    s.y2 = v % 10; v /= 10;
    s.x2 = v % 10; v /= 10;
    s.y1 = v % 10; v /= 10;
    s.x1 = v % 10; v /= 10;
    s.mask = v;
    return 0;
}

int ok (state & s) {
    if (s.x1 < 0 || s.x2 < 0 || s.x1 > N || s.x2 > N) return 0;
    if (s.y1 < 0 || s.y2 < 0 || s.y1 > M || s.y2 > M) return 0;
    return 1;
}

int isValid (state s) {
    FOR (i,1,K) {
        int t;
        if (r[i].X == s.x1 && r[i].Y == s.y1) {
           t = m[r[i].X][r[i].Y] ^ GET(s.mask,i);
           if (t == 1) return 0;
        }
        if (r[i].X == s.x2 && r[i].Y == s.y2) {
           t = m[r[i].X][r[i].Y] ^ GET(s.mask,i);
           if (t == 1) return 0;
        }
    }

    if (m[s.x1][s.y1] != 0 && h[s.x1][s.y1] == 0) {
       return 0;
    }
    if (m[s.x2][s.y2] != 0 && h[s.x2][s.y2] == 0) {
       return 0;
    }

    if (s.x1 == endx && s.y1 == endy) return 0;
    return 1;
}

int init () {
    FOR (x1,0,N) {
        FOR (y1,0,M) {
            FOR (x2,0,N) {
                FOR (y2,0,M) {
                    FOR (mask,0,((1<<(K))-1)) {
                        state s = state(x1,y1,x2,y2,mask);
                        if (isValid(s)) {
                           int t = code(s);

                           valid[t] = 1;
                        }
                    }
                }
            }
        }
    }
    return 0;
}

int init_nei () {
    FOR (x1,0,N) {
        FOR (y1,0,M) {
            FOR (x2,0,N) {
                FOR (y2,0,M) {
                    FOR (mask,0,((1<<(K))-1)) {
                    
                        state s = state(x1,y1,x2,y2,mask);
                        int t = code(s);
                        if (valid[t] == 0) continue;

                        state ns = state(x2,y2,x1,y2,mask);
                        int temp = code(ns);
                        if (ok(ns) && valid[temp]) {
                           nnum[t]++;
                        }

                        FOR (i,0,3) {
                            ns = state(x2,y2,X1,Y1,mask);
                            temp = code(ns);
                            if (ok(ns) && valid[temp]) {
                               nnum[t] ++;
                            }
                        }

                        for (unsigned i=0; i<g[x1][y1].size(); i++) {
                            int x = g[x1][y1][i].X;
                            int y = g[x1][y1][i].Y;

                            int nmask = FLIP(mask,h[x][y]);

                            ns = state(x2,y2,x1,y1,nmask);
                            temp = code(ns);
                            if (ok(ns) && valid[temp]) {
                               nnum[t]++;
                            }
                        }
                        
                    }
                }
            }
        }
    }
    return 0;
}


int read () {
    int x1,y1,x2,y2,xx1,xx2,yy1,yy2,mask,x,y;

    scanf("%d%d",&N,&M);

    FOR (i,1,N) {
        FOR (j,1,M) {
            int t;
            scanf("%d",&t);
            m[i-1][j-1] = t;
        }
    }
    N--;
    M--;

    scanf("%d",&K);

    int Free = 1;
    FOR (i,1,K) {
        scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        x1--;y1--;x2--;y2--;
        g[x1][y1].pb(mp(x2,y2));

        if (h[x2][y2] == 0) {
           h[x2][y2] = Free;
           r[Free].X = x2;
           r[Free].Y = y2;
           Free++;
        }
    }

    scanf("%d%d%d%d%d%d",&x1,&y1,&x2,&y2,&x,&y);
    x1--;y1--;x2--;y2--;x--;y--;
    endx = x;
    endy = y;

    state temp = state(x1,y1,x2,y2,0);
    Start = code(temp);

    init();
    init_nei();

 /*   FOR (i,0,N) {
        FOR (j,0,M) {
            if (m[i][j] == 1 && h[i][j] == 0) {
               t[i][j] = 1;
            }
        }
    } */

    

    return 0;
}


int end_state (state s) {
    if (s.x1 == endx && s.y1 == endy) {
       return WIN;
    }
    if (s.x2 == endx && s.y2 == endy) {
       return LOSE;
    }
    return -1;
}

int push_end_states() {
    FOR (x1,0,N) {
        FOR (y1,0,M) {
            FOR (x2,0,N) {
                FOR (y2,0,M) {
                    FOR (mask,0,((1<<(K))-1)) {
                    
                        state s = state(x1,y1,x2,y2,mask);
                        int t = code(s);
                        if (valid[t] == 0) continue;

                        int temp = end_state(s);
                        if (temp == -1) continue;

                        w[t] = temp;
                        vis[t] = 1;
                        q.push(t);
                    }
                }
            }
        }
    }
    return 0;
}


int solve () {
    push_end_states();

    state s;
    while (!q.empty()) {
          int t = q.front(); q.pop();

          if (t == Start) return 0;
          
          decode(t,s);

          state ns = state(s.x2,s.y2,s.x1,s.y1,s.mask);
          int ncode = code(ns);

          if (ok(ns) && valid[ncode]) {
                 nnum[ncode] --;
                 if (w[t] == LOSE && vis[ncode] == 0) {
                    vis[ncode] = 1;
                    w[ncode] = WIN;
                    q.push(ncode);
                 }
                 if (nnum[ncode] == 0 && vis[ncode] == 0) {
                    vis[ncode] = 1;
                    w[ncode] = LOSE;
                    q.push(ncode);
                 }
          }

          FOR (i,0,3) {
              ns = state(X2,Y2,s.x1,s.y1,s.mask);
              ncode = code(ns);
              if (ok(ns) && valid[ncode]) {
                 nnum[ncode] --;
                 if (w[t] == LOSE && vis[ncode] == 0) {
                    vis[ncode] = 1;
                    w[ncode] = WIN;
                    q.push(ncode);
                 }
                 if (nnum[ncode] == 0 && vis[ncode] == 0) {
                    vis[ncode] = 1;
                    w[ncode] = LOSE;
                    q.push(ncode);
                 }
              }
          }
          
          for (unsigned i=0; i<g[s.x2][s.y2].size(); i++) {
              int x = g[s.x2][s.y2][i].X;
              int y = g[s.x2][s.y2][i].Y;
              int nmask = FLIP(s.mask,h[x][y]);
              ns = state(s.x2,s.y2,s.x1,s.y1,nmask);
              ncode = code(ns);

              if (ok(ns) && valid[ncode]) {
                 nnum[ncode] --;
                 if (w[t] == LOSE && vis[ncode] == 0) {
                    vis[ncode] = 1;
                    w[ncode] = WIN;
                    q.push(ncode);
                 }
                 if (nnum[ncode] == 0 && vis[ncode] == 0) {
                    vis[ncode] = 1;
                    w[ncode] = LOSE;
                    q.push(ncode);
                 }
              }


          }
    }
    return 0;
}

int main () {
//    freopen(IN,"r",stdin);
//    freopen(OUT,"w",stdout);


    read();
    solve();
    


    if (w[Start] == WIN) {
       printf("1\n");
    }
    if (w[Start] == LOSE) {
       printf("2\n");
    }
    if (w[Start] == TIE) {
       printf("0\n");
    }

    return 0;
}


