#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <string>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <set>
#include <functional>
#include <iostream>
#define MOD 1000000007LL
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef pair<int,P> PP;
int h[2],w[2];
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
int dx2[8]={1,0,-1,0,1,1,-1,-1};
int dy2[8]={0,1,0,-1,1,-1,1,-1};
int fie[2][201][201];

int cnts=0;
vector<int> G[2][10005];
int cnt[2];
int col[2][105][105];
bool root[2][10005];
bool used[2][105][105];
bool used2[10005];
bool painted[2][10005];
int Gcol[2][10005];


void dfs(int val,int v,int y,int x){
	col[v][y][x]=val;
	if(fie[v][y][x]==0){
		for(int i=0;i<4;i++){
			int nx=x+dx[i],ny=y+dy[i];
			if(nx>=0 && nx<=w[v]+1 && ny>=0 && ny<=h[v]+1){
				if(fie[v][ny][nx]==0 && col[v][ny][nx]==-1){
					col[v][ny][nx]=val;
					dfs(val,v,ny,nx);
				}
			}
		}
	}else{
		for(int i=0;i<8;i++){
			int nx=x+dx2[i],ny=y+dy2[i];
			if(nx>=1 && nx<=w[v] && ny>=1 && ny<=h[v]){
				if(fie[v][ny][nx]==1 && col[v][ny][nx]==-1){
					col[v][ny][nx]=val;
					dfs(val,v,ny,nx);
				}
			}
		}
	}
}

void bfs(int v,int y,int x){
	used[v][y][x]=true;
	painted[v][col[v][y][x]]=true;
	queue<P> que;
	que.push(P(y,x));
	vector<PP> tos;
	while(que.size()){
		P q=que.front();
		que.pop();
		if(fie[v][y][x]==0){
			for(int i=0;i<4;i++){
				int nx=q.second+dx[i],ny=q.first+dy[i];
				if(nx>=0 && nx<=w[v]+1 && ny>=0 && ny<=h[v]+1){
					if(fie[v][ny][nx]!=0){
						tos.push_back(PP(col[v][ny][nx],P(ny,nx)));
					}else if(!used[v][ny][nx]){
						used[v][ny][nx]=true;
						que.push(P(ny,nx));
					}
				}
			}
		}else{
			for(int i=0;i<8;i++){
				int nx=q.second+dx2[i],ny=q.first+dy2[i];
				if(nx>=0 && nx<=w[v]+1 && ny>=0 && ny<=h[v]+1){
					if(fie[v][ny][nx]!=1){
						tos.push_back(PP(col[v][ny][nx],P(ny,nx)));
					}else if(!used[v][ny][nx]){
						used[v][ny][nx]=true;
						que.push(P(ny,nx));
					}
				}
			}
		}
	}
	for(int i=0;i<tos.size();i++){
		if(!painted[v][tos[i].first]){
			G[v][col[v][y][x]].push_back(tos[i].first);
			bfs(v,tos[i].second.first,tos[i].second.second);
		}
	}
}

string toStr(int v){
	stringstream ss;
	ss << v;
	return ss.str();
}

map<string,int> mp;

int calc(int d,int v){
	used2[v]=true;
	vector<string> vec;
	string num="";
	num+=toStr(Gcol[d][v]+1);
	for(int i=0;i<G[d][v].size();i++){
		if(!used2[G[d][v][i]]){
			vec.push_back(toStr(calc(d,G[d][v][i])));
		}
	}
	if(vec.size()>0)num+=',';
	sort(vec.begin(),vec.end());
	for(int i=0;i<vec.size();i++){
		num+=vec[i];
		if(i+1<vec.size())num+=',';
	}
	if(mp.find(num)==mp.end()){
		mp[num]=mp.size();
	}
	return mp[num];
}


bool solve(){
	for(int i=0;i<10005;i++){
		G[0][i].clear();
		G[1][i].clear();
	}
	cnt[0]=0;
	cnt[1]=0;
	memset(root,false,sizeof(root));
	memset(col,-1,sizeof(col));
	for(int i=0;i<2;i++){
		for(int j=0;j<=h[i]+1;j++){
			for(int k=0;k<=w[i]+1;k++){
				if(col[i][j][k]==-1){
					Gcol[i][cnt[i]]=fie[i][j][k];
					dfs(cnt[i]++,i,j,k);
				}
			}
		}
	}
	memset(used,false,sizeof(used));
	memset(painted,false,sizeof(painted));
	for(int i=0;i<2;i++){
		for(int j=0;j<=h[i]+1;j++){
			for(int k=0;k<=w[i]+1;k++){
				if(!used[i][j][k]){
					bfs(i,j,k);
				}
			}
		}
	}
	mp.clear();
	mp["0"]=0;
	mp["1"]=1;
	mp["2"]=2;
	memset(used2,false,sizeof(used2));
	int v1=calc(0,0);
	memset(used2,false,sizeof(used2));
	int v2=calc(1,0);
	if(v1==v2)return true;
	return false;
}

int main(void){
	while(1){
		cnts++;
		memset(fie,0,sizeof(fie));
		for(int k=0;k<2;k++){
			scanf("%d%d",&h[k],&w[k]);
			if(h[k]==0 && w[k]==0)return 0;
			for(int i=1;i<=h[k];i++){
				string str;
				cin >> str;
				for(int j=1;j<=w[k];j++){
					if(str[j-1]=='.'){
						fie[k][i][j]=0;
					}else{
						fie[k][i][j]=1;
					}
				}
			}
		}
		printf("%s\n",solve()?"yes":"no");
	}
	return 0;
}

Measured memory_bytes: 4456