//gh[][]为有向图（gh[i][j]为结点i到结点j的权值，如果gh[i][j]不存在，则为-1）
//dis[] 中所有元素应初始化为INFINITY(0xfffffff最大值)
//vis[] 中所有元素应初始化为false。
//num[] 记录各结点入队列次数

bool spfa(int s){
    //若 s 为终点，直接返回
    //path[] 用于记录路径
    
    queue<int> Q;
    
    Q.push(s);
    dis[s] = 0;
    
    while(!Q.empty()) {
        int u = Q.front();
        Q.pop();
        vis[u] = true;
        
        for (int v = 1; v <= n; v++) {
            if (dis[v] > dis[u] + gh[u][v]){
                dis[v] = dis[u] + gh[u][v];
                //path[v] = u;
                //num[v]++;
                //if (num[v] > n) return false;    //判断负环
                if (!vis[v]) {
                    vis[v] = true;
                    Q.push(v);
                }
            }
        }
        vis[u] = false; //将出队列的的点置为false
    }
    return true;
}

//注意：结点标号从1开始！

//u1 -- v1
//u2 -- v2

bool gh[][] //graph that if two points is connected

bool b[]    //if b[v] is used
int link[]  //link[v] = u

bool Find(int u){
    for (int v = 1; v <= (v); v++){
        if (gh[u][v] && !b[v]){
            b[v] = true;
            
            //如果结点标号从0开始,可以使用 link[v] == -1
            if (link[v] == 0 || Find(link[v])){
                link[v] = u;
                return true;
            }
        }
    }
    return false;
}

int main(){
    int ans = 0;
    for (int i = 1; i <= (u); i++){
        memset(b, 0, sizeof(b));
        if (Find(i)) ans++;
    }
    //ans为边的匹配数
}

class UnionFind{
private:
    vector<int> father;
    vector<int> sum;//the number of child as root
public:
    void Init(int n){
        father.clear();
        father.resize(n+2);//start from 1
        sum.clear();
        sum.resize(n+2);
        for (int i=1; i<= n; i++){
            father[i] = i;
            sum[i] = 0;
        }
    }

    bool Is_same(int x, int y){
        return GetFather(x) == GetFather(y);
    }

    void Union(int x, int y){
        father[GetFather(x)] = GetFather(y);
    }

    int GetFather(int x){
        if (father[x] == x) return x;
        else return father[x] = GetFather(father[x]);
    }

    int FindGroups(){
        int ans = 0;
        for (int i=1; i<=father.size()-2; i++){
            sum[GetFather(i)]++;
        }
        for (int i=1; i<=father.size()-2; i++){
            if (sum[i]) ans++;
        }
        return ans;
    }
};

struct node {
    int priority;
    int value;
    
    friend bool operator < (node n1, node n2){
       return n1.priority < n2.priority;    较大值优先
       //return n1.priority > n2.priority;  较小值优先
    }
};

//对于基本类型，要使队列头部元素最小，可以使用一下声明
priority_queue<int, vector<int>, greater<int> > q;

//From UVA 314
#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
using namespace std;

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

class Problem{
private:
    int n, m;
    int startx, starty, endx, endy;
    int direction;

    int gh[52][52];
    bool vis[52][52][4];

    struct state{
        int x, y, d, step;
    };
public:
    void Solve(){
        while(Read()){
            if (startx == endx && starty == endy){
                printf("%d\n",0);
            }else{
                printf("%d\n", BFS(startx,starty,direction,0));
            }
        }
    }

    int BFS(int x, int y, int d, int s){
        struct state u, v;
        queue<struct state> q;
        u.x = x;
        u.y = y;
        u.d = d;
        u.step = s;
        q.push(u);

        while(!q.empty()){
            u = q.front();
            q.pop();
            
            for (int i=1; i<4; i=i+2){
                v = u;
                v.d = (v.d + i)%4;
                v.step++;
                if (!vis[v.x][v.y][v.d]) q.push(v);
                vis[v.x][v.y][v.d] = true;
            }

            for (int i=1; i<4; i++){
                v = u;
                v.x += i * dx[u.d];
                v.y += i * dy[u.d];
                v.step++;
        
                if (v.x<=0 || v.y<=0 || v.x>=m || v.y>=n)
                    continue;//border!!!
                if (gh[v.x][v.y] == 1)
                    break;//careful!!!(not continue)
                if (v.x == endx && v.y == endy)
                    return v.step;

                if (!vis[v.x][v.y][v.d]) q.push(v);
                vis[v.x][v.y][v.d] = true;
            }
        }
        return -1;
    }

    bool Read(){
        int tmp;
        string dirt;
        scanf("%d%d", &m, &n);
        if (n==0 && m==0) return false;
        Init();
        for (int i=0; i<m; i++){
            for (int j=0; j<n; j++){
                cin >> tmp;
                if (tmp){
                    gh[i][j] = gh[i+1][j] = 1;
                    gh[i][j+1] = gh[i+1][j+1] = 1;
                }
            }
        }
        scanf("%d%d%d%d", &startx, &starty, &endx, &endy);
        cin >> dirt;
        if (dirt == "north"){
            direction = 0;
        }else if (dirt == "west"){
            direction = 1;
        }else if (dirt == "south"){
            direction = 2;
        }else if (dirt == "east"){
            direction = 3;
        }
        return true;
    }

    void Init(){
        memset(gh, 0, sizeof(gh));
        memset(vis, 0, sizeof(vis));
    }
};

int main(){
    Problem ro;
    ro.Solve();
}

//非递归实现
int binary_search(int A[], int key, int imin, int imax){
  // continue searching while [imin,imax] is not empty
  while (imax >= imin){
      // calculate the midpoint for roughly equal partition
      int imid = midpoint(imin, imax);
      // eg: imid = (imin+imax)>>1
      
      if(A[imid] == key)
        // key found at index imid
        return imid; 
      // determine which subarray to search
      else if (A[imid] < key)
        // change min index to search upper subarray
        imin = imid + 1;
      else         
        // change max index to search lower subarray
        imax = imid - 1;
    }
  // key was not found
  return KEY_NOT_FOUND;
}

class myclass {
public:
    int first， second;
    bool operator < (const myclass &m)const {
        return first < m.first;
    }//ascending order by first
};
vector< myclass > vect;
sort(vect.begin(), vect.end());

----------------------------------------------------

bool cmp(const myclass & m1, const myclass & m2) {
    return m1.second < m2.second;
}//ascending order by second
sort(vect.begin(), vect.end(), cmp);

std::vector<int> myvector;
for (int i=1; i<10; ++i) myvector.push_back(i);   // 1 2 3 4 5 6 7 8 9
std::reverse(myvector.begin(),myvector.end());    // 9 8 7 6 5 4 3 2 1

int myints[] = {1,2,3};
do {
    std::cout << myints[0] << ' ' << myints[1] << ' ' << myints[2] << '\n';
} while (next_permutation(myints,myints+3) );
cout << "After loop: " << myints[0] << ' ' << myints[1] << ' ' << myints[2] << '\n';

Output:
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
After loop: 1 2 3