#include <cstdio>

#include <iostream>

#include <algorithm>

#include <string.h>

#include <stdlib.h>

#include <cmath>

#include <queue>

using namespace std;

typedef long long LL;

const int INF=0x3f3f3f3f;

const int N=1e3+;

struct Node{

  int t,x,y;

};

queue<Node>q;

char c[N][N];

int  s[][N][N],n,m;

char p[]="0+-|^><vLRUD*";

int a[]={,,,,,,,,,,,,};

int b[]={,,,,,,,,,,,,};

int dp[][N][N];

bool judgel(int x){

  if(x==||x==||x==||x==||x==||x==)

    return true;

  return false;

}

bool judger(int x){

  if(x==||x==||x==||x==||x==||x==)

    return true;

  return false;

}

bool judgeu(int x){

  if(x==||x==||x==||x==||x==||x==)

    return true;

  return false;

}

bool judged(int x){

  if(x==||x==||x==||x==||x==||x==)

    return true;

  return false;

}

int main(){

    scanf("%d%d",&n,&m);

    for(int i=;i<=n;++i)

      scanf("%s",c[i]+);

    for(int i=;i<=n;++i)

    {

      for(int j=;j<=m;++j)

      {

        for(int k=;k<=;++k)

         if(c[i][j]==p[k])

         {

            s[][i][j]=a[k];

            break;

         }

       }

    }

    for(int k=;k<=;++k)

    {

      for(int i=;i<=n;++i)

      {

        for(int j=;j<=m;++j)

        {

           s[k][i][j]=b[s[k-][i][j]];

        }

      }

    }

    Node st,aim;

    scanf("%d%d%d%d",&st.x,&st.y,&aim.x,&aim.y);

    memset(dp,-,sizeof(dp));

    st.t=;

    q.push(st);dp[][st.x][st.y]=;

    int ans=INF;

    while(!q.empty()){

      Node u=q.front();

      q.pop();

      if(u.x==aim.x&&u.y==aim.y){

        break;

      }

      Node e=u;e.t=(e.t+)%;

      if(dp[e.t][e.x][e.y]==-){

        dp[e.t][e.x][e.y]=dp[u.t][e.x][e.y]+;

        q.push(e);

      }

      if(u.y>&&judgel(s[u.t][u.x][u.y])&&judger(s[u.t][u.x][u.y-])){

          if(dp[u.t][u.x][u.y-]==-){

             e=u;--e.y;

             dp[e.t][e.x][e.y]=dp[u.t][u.x][u.y]+;

             q.push(e);

          }

      }

      if(u.y<m&&judger(s[u.t][u.x][u.y])&&judgel(s[u.t][u.x][u.y+])){

            if(dp[u.t][u.x][u.y+]==-){

             e=u;++e.y;

             dp[e.t][e.x][e.y]=dp[u.t][u.x][u.y]+;

             q.push(e);

          }

      }

      if(u.x>&&judgeu(s[u.t][u.x][u.y])&&judged(s[u.t][u.x-][u.y])){

            if(dp[u.t][u.x-][u.y]==-){

             e=u;--e.x;

             dp[e.t][e.x][e.y]=dp[u.t][u.x][u.y]+;

             q.push(e);

          }

      }

      if(u.x<n&&judged(s[u.t][u.x][u.y])&&judgeu(s[u.t][u.x+][u.y])){

            if(dp[u.t][u.x+][u.y]==-){

             e=u;++e.x;

             dp[e.t][e.x][e.y]=dp[u.t][u.x][u.y]+;

             q.push(e);

          }

      }

    }

    for(int i=;i<;++i)

      if(dp[i][aim.x][aim.y]!=-){

        ans=min(dp[i][aim.x][aim.y],ans);

      }

      if(ans==INF)ans=-;

     printf("%d\n",ans);

    return ;

}