#include<cstdio>

#include<algorithm>

#include<cctype>

#include<cstring>

#include<cstdlib>

#include<queue>

#define maxn 1000

using namespace std;

inline long long read(){

    long long num=,f=;

    char ch=getchar();

    while(!isdigit(ch)){

        if(ch=='-')    f=-;

        ch=getchar();

    }

    while(isdigit(ch)){

        num=num*+ch-'';

        ch=getchar();

    }

    return num*f;

}

int u[]={,,,,-};

int w[]={,,,-,};

struct Edge{

    int next,to,val;

}edge[maxn*];

int head[maxn],num;

inline void addedge(int from,int to,int val){

    edge[++num]=(Edge){head[from],to,val};

    head[from]=num;

}

inline void add(int from,int to,int val){

    addedge(from,to,val);

    addedge(to,from,);

}

inline int count(int i){    return i&?i+:i-;    }

int pre[maxn];

int Start,End;

bool vis[maxn];

int dfn[maxn];

int list[maxn];

bool bfs(){

    memset(vis,,sizeof(vis));    dfn[Start]=;    vis[Start]=;

    queue<int>q;    q.push(Start);

    while(!q.empty()){

        int from=q.front();    q.pop();

        for(int i=head[from];i;i=edge[i].next){

            int to=edge[i].to;

            if(vis[to]||edge[i].val<=)    continue;

            vis[to]=;    dfn[to]=dfn[from]+;

            q.push(to);

        }

    }

    return vis[End];

}

int dfs(int x,int val){

    if(val==||x==End)    return val;

    vis[x]=;    int flow=;

    for(int &i=list[x];i;i=edge[i].next){

        int to=edge[i].to;

        if(vis[to]||dfn[to]!=dfn[x]+||edge[i].val<=)    continue;

        int now=dfs(to,min(val,edge[i].val));

        if(x!=End)    pre[to]=x;    edge[i].val-=now;    edge[count(i)].val+=now;    val-=now;    flow+=now;

        if(val<=)    break;

    }

    if(val!=flow)    dfn[x]=-;

    return flow;

}

inline int maxflow(){

    int ans=;

    while(bfs()){

        memset(vis,,sizeof(vis));

        for(int i=Start;i<=End;++i)    list[i]=head[i];

        int now=dfs(Start,0x7fffffff);

        if(now==)    break;

        ans+=now;

    }

    return ans;

}

int s[maxn][maxn];

char c[maxn];

bool ext[maxn][maxn];

int dis[][][];

int v[maxn];

bool exa[maxn];

int f[maxn][maxn];

int sum[maxn];

struct Node{

    int x,y;

}que[maxn];

int main(){

    memset(dis,/,sizeof(dis));    int inf=dis[][][];

    int n=read();

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

        scanf("%s",c+);

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

            if(c[j]=='*')    s[i][j]=;

            else             s[i][j]=;

    }

    int p=read();    End=p*+;

    for(int i=;i<=p;++i)    que[i]=(Node){read(),read()};

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

        add(Start,i,);    add(i+p,End,);

        queue<Node>q;    q.push(que[i]);    dis[i][que[i].x][que[i].y]=;

        while(!q.empty()){

            Node from=q.front();    q.pop();

            //printf("%d %d %d<<<<<<<<\n",i,from.x,from.y);

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

                int nx=from.x+u[j];

                int ny=from.y+w[j];

                //printf("%d %d %d %d><>\n",nx,ny,s[nx][ny],dis[i][from.x][from.y]);

                if(nx<||nx>n||ny<||ny>n||s[nx][ny]||dis[i][nx][ny]!=inf)    continue;

                dis[i][nx][ny]=dis[i][from.x][from.y]+;

                q.push((Node){nx,ny});

            }

        }

    }

    for(int i=;i<=p;++i)    v[i]=read();

    int r=read();

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

        int t=read(),x=read(),y=read(),d=read();    sum[d]++;

        for(int j=;j<=p;++j){

            //printf("%d %d>>>\n",j,dis[j][x][y]);

            int ret=v[d]*t;

            if(ret>=dis[j][x][y])    f[j][d]++;

        }

    }

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

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

            if(sum[i]==f[j][i])    add(j,i+p,);

    maxflow();

    for(int i=+p;i<End;++i){

        for(int j=head[i];j;j=edge[j].next){

            int to=edge[j].to;

            if(to==End||edge[j].val==)    continue;

            printf("%d %d %d\n",i-p,que[to].x,que[to].y);

            break;

        }

    }

    return ;

}