#include<bits/stdc++.h>

using namespace std;

const int maxi=200;
#define pb push_back

int n,m;
int a[maxi][maxi];
int t,k;
int x[maxi],y[maxi];
vector<pair<int,int>> coord[maxi];
string command;
pair<int,int> pre[maxi][maxi];
pair<int,int> sl[maxi];
int ob[maxi][maxi],ob1[maxi][maxi];
int daljina[maxi][maxi];

int distance(pair<int,int> x, pair<int,int> y)
{
     return (abs(x.first-y.first)+abs(x.second-y.second));
}

void prepare_some_stuffs()
{
   sl[0].first=1;
   sl[1].first=-1;
   sl[2].second=1;
   sl[3].second=-1;

   return;
}
char from_to(int x11, int y11, int x22,int y22)
{
    if (x11==x22 && y11>y22) return 'W';
    if (x11==x22) return 'E';
    if (x11>x22) return 'N';
    return 'S';
}

int calc_score(int com, vector<pair<int,int > > pos)
{
   int ans=com;
   int dis=0;

   for (auto i:pos)
    for (auto j:pos)
    dis=max(dis,distance(i,j));

    ans+=(n+m)*dis;

    return ans;
}

void insert_coord(vector<pair<int,int>> pos)
{
   for (int i=0;i<k;i++)
   {
       x[i+1]=pos[i].first;
       y[i+1]=pos[i].second;
   }
}

int fine_to_move(int x, int y, int xi, int yi)
{
    if (xi+x>n || xi+x<=0) return 0;
    if (yi+y>m || yi+y<=0) return 0;
    if (a[xi+x][yi+y]==1)  return 0;
    return 1;
}

void move_all(char ch)
{
    int xi=0;
    int yi=0;

    if (ch=='W') yi=-1;
    if (ch=='E') yi=1;
    if (ch=='N') xi=-1;
    if (ch=='S') xi=1;

    for (int i=1;i<=k;i++)
        if (fine_to_move(x[i],y[i],xi,yi))
    {
        x[i]+=xi;
        y[i]+=yi;
    }
   return;
}

vector<pair<int,int>> reconstruct(int endx,int endy, int startx, int starty)
{
    vector<pair<int,int>> sol;

    while(endx!=startx || endy!=starty)
     {
         sol.pb({endx,endy});
         int pomx=pre[endx][endy].first;
         int pomy=pre[endx][endy].second;
         endx=pomx;
         endy=pomy;
     }

     sol.pb({startx,starty});

     reverse(sol.begin(),sol.end());

    return sol;
}

vector<pair<int,int>> bfs(int startx,int starty, int endx,int endy)
{
   queue<pair<int,int>> q;

   for (int i=1;i<=n;i++)
    for (int j=1;j<=m;j++)
        pre[i][j]={-1,-1};

     q.push({startx,starty});

     while(!q.empty())
     {
          int x=q.front().first;
          int y=q.front().second;
          q.pop();

          for (int i=0;i<4;i++)
            if (fine_to_move(x,y,sl[i].first,sl[i].second)  && pre[x+sl[i].first][y+sl[i].second].first==-1)
          {
              pre[x+sl[i].first][y+sl[i].second]={x,y};
              q.push({x+sl[i].first,y+sl[i].second});
          }
     }

     vector<pair<int,int> > sol= reconstruct(endx,endy,startx,starty);

     return sol;
}

void simulation(vector<pair<int,int>> moves)
{
    for (int i=0;i<moves.size()-1;i++)
    {
        char cmd=from_to(moves[i].first,moves[i].second,moves[i+1].first,moves[i+1].second);
        command=command+cmd;
        //cout<<cmd<<"\n";
        move_all(cmd);
    }
}

vector<pair<int ,pair<int,int >> > pos_end;

int whole_distance(pair<int,int> xa)
{
    int dist1=0;

    for (int i=1;i<=k;i++)
        dist1+=distance(xa,{x[i],y[i]});

    return dist1;
}

void run_dfs(int x, int y)
{
   ob[x][y]=1;

   int result=1-fine_to_move(x,y,1,0);
   result+=1-fine_to_move(x,y,-1,0);
   result+=1-fine_to_move(x,y,0,1);
   result+=1-fine_to_move(x,y,0,-1);

   int usao=0;

   for (int i=0;i<4;i++)
    if (fine_to_move(x,y,sl[i].first,sl[i].second) && !ob[x+sl[i].first][y+sl[i].second])
    {
        usao++;
        run_dfs(x+sl[i].first,y+sl[i].second);
    }

    if (result>=2 ) {
        result=daljina[x][y];
        pos_end.pb({result,{x,y}});
    }

    return ;
}

void obidji_sve(int x, int y)
{
    queue<pair<pair<int,int>,int>> q;

    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++)
        ob1[i][j]=0;

     ob1[x][y]=1;
     q.push({{x,y},0});

    while(!q.empty()){

        int x=q.front().first.first;
        int y=q.front().first.second;
        int vreme=q.front().second;
        q.pop();
        daljina[x][y]+=vreme;

         for (int i=0;i<4;i++)
            if (fine_to_move(x,y,sl[i].first,sl[i].second) && !ob1[x+sl[i].first][y+sl[i].second])
            {
               ob1[x+sl[i].first][y+sl[i].second]=1;
               q.push({{x+sl[i].first,y+sl[i].second},vreme+1});
            }
    }
   return;
}

void prepare_for_dfs(int x, int y)
{
     for (int i=1;i<=n;i++)
      for (int j=1;j<=m;j++)
      ob[i][j]=0;

       pos_end.clear();

      run_dfs(x,y);

      sort(pos_end.begin(),pos_end.end());
}

vector<pair<int,int>> solve(vector<pair<int,int>> pos ,int cord_x,int cord_y)
{
   vector<pair<int,int>> sol;
   insert_coord(pos);

     int p=2;

     while(p--){
    for (int i=1;i<=k;i++)
    {
       vector<pair<int,int> > moves= bfs(x[i],y[i],cord_x,cord_y);
       simulation(moves);
      }
    }

    for (int i=1;i<=k;i++)
        sol.pb({x[i],y[i]});

   return sol;
}

int main()
{
    freopen("robots.in","r",stdin);
    scanf("%d%d",&n,&m);

    prepare_some_stuffs();

     for (int i=1;i<=n;i++)
     {
         string s;
         cin>>s;
         for (int j=0;j<m;j++)
            if (s[j]=='.') a[i][j+1]=0; else
            a[i][j+1]=1;
     }

     scanf("%d%d",&t,&k);

     int best_ans=1e9;
     int best_poz=0;
     int best_endx=0;
     int best_endy=0;

    for (int i=1; i<=t; i++)
    {
        for(int j=1; j<=k; j++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            coord[i].pb({x,y});
            obidji_sve(x,y);
        }

        insert_coord(coord[i]);

        prepare_for_dfs(coord[i][0].first,coord[i][0].second);

        for (int w=0; w<min(9,(int)pos_end.size()); w++)
        {
            command="";
            int cord_x=pos_end[w].second.first;
            int cord_y=pos_end[w].second.second;

            vector<pair<int,int> > after_coord= solve(coord[i],cord_x,cord_y);
            if (command=="") command="N";

            int value= calc_score(command.size(),after_coord);

            if (value<best_ans)
            {
                best_ans=value;
                best_poz=i;

                best_endx=cord_x;
                best_endy=cord_y;
            }
        }
    }

  fclose(stdin);

   freopen("robots.out","w",stdout);
     printf("%d\n",best_poz);

     command="";
     vector<pair<int,int> > after_coord=solve(coord[best_poz],best_endx,best_endy);
     if (command=="") command="N";

     //cout<<calc_score(command.size(),after_coord)<<"\n";

     cout<<command<<"\n";
    fclose(stdout);


    return 0;
}