/** @JUDGE_ID: GOKURI_SQUEEZE ??? C++ */
#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <fstream>
using namespace std;

#define FNAME "erythea.txt"
#define cin fin
typedef vector< vector<int> > vvint;

typedef pair<int,int> vert;
typedef int           len_t;
typedef pair<len_t,vert> edge;
typedef vector<edge>     edges;
typedef map<vert,edges>  graph;

len_t dijkstra( graph& G, vert src, vert dst )
{
  set<vert> visited;
  priority_queue<edge, vector<edge>, greater<edge> > Q;
  Q.push( edge(0,src) );
  while( !Q.empty() )
    {
      edge c = Q.top(); Q.pop();
      if( visited.count(c.second) )
        continue;
      if( c.second == dst )
        return c.first;
      visited.insert(c.second);
      edges& ne = G[c.second];
      for(int i=0; i!=ne.size(); ++i)
        if( !visited.count(ne[i].second) )
          Q.push( edge(c.first+ne[i].first, ne[i].second) );
    }
  return -1;
}

int main()
{
  ifstream fin(FNAME);
  if(!fin) return -1;

  int M; cin >> M;
  while(M--)
    {
      // read input
      int Y, X;
      cin >> Y >> X;
      int sy,sx,dy,dx;
      cin >> sy >> sx >> dy >> dx;

      vector< vector<int> > flag( Y, vector<int>(X) );
      for(int y=0; y!=Y; ++y)
        for(int x=0; x!=X; ++x)
          {
            char c; cin >> c;
            flag[y][x] = c-'0';
          }

      // TODO: calc risk levels 
      vector< vector<int> > risk( Y+1, vector<int>(X+1,-1) );
      for(int y=0; y<=Y; ++y)
        for(int x=0; x<=X; ++x)
          if(
            (y<Y && x<X && flag[y][x]) ||
            (y<Y && 0<x && flag[y][x-1]) ||
            (0<y && x<X && flag[y-1][x]) ||
            (0<y && 0<x && flag[y-1][x-1])
          )
            risk[y][x] = 0;
      for(int d=0; d<=Y+X; ++d)
        {
          bool changed = false;
          for(int y=0; y<=Y; ++y)
            for(int x=0; x<=X; ++x)
              if( risk[y][x] == -1 )
                if(
                  (y<Y && d==risk[y+1][x]) ||
                  (0<y && d==risk[y-1][x]) ||
                  (x<X && d==risk[y][x+1]) ||
                  (0<x && d==risk[y][x-1])
                )
                  changed=true, risk[y][x] = d+1;
          if( !changed ) break;
        }
//      for(int y=0; y<=Y; ++y,cout<<endl)
//        for(int x=0; x<=X; ++x)
//          cout << risk[y][x];
      for(int y=0; y<=Y; ++y)
        for(int x=0; x<=X; ++x)
          risk[y][x] = X+Y-risk[y][x];

      // make a graph
      graph G;
      for(int x=0; x<=X; ++x)
        for(int y=0; y<=Y; ++y)
          {
            // (y,x) <==> (y+1,x)
            if( y < Y )
              {
                bool exist = x==0 || x==X || !(flag[y][x-1]&&flag[y][x]);
                if( exist )
                  G[vert(y,x)].push_back( edge(risk[y+1][x],vert(y+1,x)) ),
                  G[vert(y+1,x)].push_back( edge(risk[y][x],vert(y,x)) );
              }
            // (y,x) <==> (y,x+1)
            if( x < X )
              {
                bool exist = y==0 || y==Y || !(flag[y-1][x]&&flag[y][x]);
                if( exist )
                  G[vert(y,x)].push_back( edge(risk[y][x+1],vert(y,x+1)) ),
                  G[vert(y,x+1)].push_back( edge(risk[y][x],vert(y,x)) );
              }
          }

      // shortest path is...
      len_t len = dijkstra( G, vert(sy,sx), vert(dy,dx) );
      if( len >= 0 )
        cout << len+risk[sy][sx] << endl;
      else
        cout << "no solution" << endl;
    }

  
  return 0;
}