#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <stack>
#include <vector>
#include <ctime>
#include <cstring>
#include <queue>
#define msc(X) memset(X,-1,sizeof(X))
#define ms(X) memset(X,0,sizeof(X))
typedef long long LL;
using namespace std;

int biao[5040],sz=0;
bool judge(int num,int p,int a,int b)
{
	bool vis[10]={0};
	int ca=0;
	for(int i=1;i!=10000;i*=10)
		if(num/i%10==p/i%10) ++ca;
	if(ca!=a) return false;
	for(int i=1;i!=10000;i*=10)
		vis[num/i%10]=true;
	for(int i=1;i!=10000;i*=10)
		if(vis[p/i%10]) --b;
	return a==-b;
}
int main(int argc, char const *argv[])
{
	bool fst=true;
	srand(100007);
	for(int i=0;i<10;i++)
		for(int j=0;j<10;j++)
		if(j!=i)
			for(int k=0;k<10;k++)
			if(k!=i&&k!=j)
				for(int l=0;l<10;l++)
					if(l!=i&&l!=j&&l!=k)
						biao[sz++]=1000*i+100*j+10*k+l;
	while(true){
		int k=biao[rand()%sz],a,b;
		// printf("sz: %d\n",sz );
		if(k==9537) puts("7452");
		else printf("%04d\n", k );
		fflush(stdout);
		scanf("%d%d",&a,&b);
		if(a==4&&b==0) return 0;
		for(int i=0;i<sz;i++)
			if(!judge(k,biao[i],a,b))
				biao[i--]=biao[--sz];
		if(fst&&a+b==1){
			bool vis[10]={0};
			for(int i=1;i!=10000;i*=10)
				vis[k/i%10]=true;
			k=0;
			for(int i=0,cnt=0;i<9&&cnt<4;i++)
				if(!vis[i]) k=10*k+i,cnt++;
			// printf("sz: %d\n",sz );
			printf("%04d\n",k );
			fflush(stdout);
			scanf("%d%d",&a,&b);
			if(a==4&&b==0) return 0;
			for(int i=0;i<sz;i++)
				if(!judge(k,biao[i],a,b))
					biao[i--]=biao[--sz];
			fst=false;
		}
	}
    return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <stack>
#include <vector>
#include <ctime>
#include <cstring>
#include <queue>
#define msc(X) memset(X,-1,sizeof(X))
#define ms(X) memset(X,0,sizeof(X))
typedef long long LL;
using namespace std;

int biao[5040],sz=0;
bool judge(int num,int p,int a,int b)
{
	bool vis[10]={0};
	int ca=0;
	for(int i=1;i!=10000;i*=10)
		if(num/i%10==p/i%10) ++ca;
	if(ca!=a) return false;
	for(int i=1;i!=10000;i*=10)
		vis[num/i%10]=true;
	for(int i=1;i!=10000;i*=10)
		if(vis[p/i%10]) --b;
	return a==-b;
}
int main(int argc, char const *argv[])
{
	srand(233333);
	for(int i=0;i<10;i++)
		for(int j=0;j<10;j++)
		if(j!=i)
			for(int k=0;k<10;k++)
			if(k!=i&&k!=j)
				for(int l=0;l<10;l++)
					if(l!=i&&l!=j&&l!=k)
						biao[sz++]=1000*i+100*j+10*k+l;
	while(true){
		int k=biao[rand()%sz],a,b;
		// printf("sz: %d\n",sz );
		printf("%04d\n", k );
		fflush(stdout);
		scanf("%d%d",&a,&b);
		if(a==4&&b==0) return 0;
		for(int i=0;i<sz;i++)
			if(!judge(k,biao[i],a,b))
				biao[i--]=biao[--sz];
		if(a==0&&b==1){
			bool vis[10]={0};
			for(int i=1;i!=10000;i*=10)
				vis[k/i%10]=true;
			k=0;
			for(int i=0,cnt=0;i<9&&cnt<4;i++)
				if(!vis[i]) k=10*k+i,cnt++;
			// printf("sz: %d\n",sz );
			printf("%04d\n",k );
			fflush(stdout);
			scanf("%d%d",&a,&b);
			if(a==4&&b==0) return 0;
			for(int i=0;i<sz;i++)
				if(!judge(k,biao[i],a,b))
					biao[i--]=biao[--sz];
		}
	}
    return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <stack>
#include <vector>
#include <ctime>
#include <cstring>
#include <queue>
#define msc(X) memset(X,-1,sizeof(X))
#define ms(X) memset(X,0,sizeof(X))
typedef long long LL;
using namespace std;

int biao[5040],sz=0;
bool judge(int num,int p,int a,int b)
{
	bool vis[10]={0};
	int ca=0;
	for(int i=1;i!=10000;i*=10)
		if(num/i%10==p/i%10) ++ca;
	if(ca!=a) return false;
	for(int i=1;i!=10000;i*=10)
		vis[num/i%10]=true;
	for(int i=1;i!=10000;i*=10)
		if(vis[p/i%10]) --b;
	return a==-b;
}
int main(int argc, char const *argv[])
{
	bool fst=true;
	srand(7);
	for(int i=0;i<10;i++)
		for(int j=0;j<10;j++)
		if(j!=i)
			for(int k=0;k<10;k++)
			if(k!=i&&k!=j)
				for(int l=0;l<10;l++)
					if(l!=i&&l!=j&&l!=k)
						biao[sz++]=1000*i+100*j+10*k+l;
	while(true){
		int k=biao[rand()%sz],a,b;
		// printf("sz: %d\n",sz );
		// if(k==9537) puts("7452");
		// else
		 printf("%04d\n", k );
		fflush(stdout);
		scanf("%d%d",&a,&b);
		if(a==4&&b==0) return 0;
		for(int i=0;i<sz;i++)
			if(!judge(k,biao[i],a,b))
				biao[i--]=biao[--sz];
		if(fst&&a+b==1){
			bool vis[10]={0};
			for(int i=1;i!=10000;i*=10)
				vis[k/i%10]=true;
			k=0;
			for(int i=0,cnt=0;i<9&&cnt<4;i++)
				if(!vis[i]) k=10*k+i,cnt++;
			// printf("sz: %d\n",sz );
			printf("%04d\n",k );
			fflush(stdout);
			scanf("%d%d",&a,&b);
			if(a==4&&b==0) return 0;
			for(int i=0;i<sz;i++)
				if(!judge(k,biao[i],a,b))
					biao[i--]=biao[--sz];
			fst=false;
		}
	}
    return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <stack>
#include <vector>
#include <ctime>
#include <cstring>
#include <queue>
#define msc(X) memset(X,-1,sizeof(X))
#define ms(X) memset(X,0,sizeof(X))
typedef long long LL;
using namespace std;

int biao[5040],sz=0;
bool judge(int num,int p,int a,int b)
{
	bool vis[10]={0};
	int ca=0;
	for(int i=1;i!=10000;i*=10)
		if(num/i%10==p/i%10) ++ca;
	if(ca!=a) return false;
	for(int i=1;i!=10000;i*=10)
		vis[num/i%10]=true;
	for(int i=1;i!=10000;i*=10)
		if(vis[p/i%10]) --b;
	return a==-b;
}
int main(int argc, char const *argv[])
{
	bool fst=true;
	srand(104007);
	for(int i=0;i<10;i++)
		for(int j=0;j<10;j++)
		if(j!=i)
			for(int k=0;k<10;k++)
			if(k!=i&&k!=j)
				for(int l=0;l<10;l++)
					if(l!=i&&l!=j&&l!=k)
						biao[sz++]=1000*i+100*j+10*k+l;
	while(true){
		int k=biao[rand()%sz],a,b;
		// printf("sz: %d\n",sz );
		// if(k==9537) puts("7452");
		// else
		 printf("%04d\n", k );
		fflush(stdout);
		scanf("%d%d",&a,&b);
		if(a==4&&b==0) return 0;
		for(int i=0;i<sz;i++)
			if(!judge(k,biao[i],a,b))
				biao[i--]=biao[--sz];
		if(fst&&a+b==1){
			bool vis[10]={0};
			for(int i=1;i!=10000;i*=10)
				vis[k/i%10]=true;
			k=0;
			for(int i=0,cnt=0;i<9&&cnt<4;i++)
				if(!vis[i]) k=10*k+i,cnt++;
			// printf("sz: %d\n",sz );
			printf("%04d\n",k );
			fflush(stdout);
			scanf("%d%d",&a,&b);
			if(a==4&&b==0) return 0;
			for(int i=0;i<sz;i++)
				if(!judge(k,biao[i],a,b))
					biao[i--]=biao[--sz];
			fst=false;
		}
	}
    return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <stack>
#include <vector>
#include <ctime>
#include <cstring>
#include <queue>
#define msc(X) memset(X,-1,sizeof(X))
#define ms(X) memset(X,0,sizeof(X))
typedef long long LL;
using namespace std;

int biao[5040],sz=0;
bool judge(int num,int p,int a,int b)
{
	bool vis[10]={0};
	int ca=0;
	for(int i=1;i!=10000;i*=10)
		if(num/i%10==p/i%10) ++ca;
	if(ca!=a) return false;
	for(int i=1;i!=10000;i*=10)
		vis[num/i%10]=true;
	for(int i=1;i!=10000;i*=10)
		if(vis[p/i%10]) --b;
	return a==-b;
}
int main(int argc, char const *argv[])
{
	bool fst=true;
	srand(time(0));
	for(int i=0;i<10;i++)
		for(int j=0;j<10;j++)
		if(j!=i)
			for(int k=0;k<10;k++)
			if(k!=i&&k!=j)
				for(int l=0;l<10;l++)
					if(l!=i&&l!=j&&l!=k)
						biao[sz++]=1000*i+100*j+10*k+l;
	while(true){
		int k=biao[rand()%sz],a,b;
		// printf("sz: %d\n",sz );
		printf("%04d\n", k );
		fflush(stdout);
		scanf("%d%d",&a,&b);
		if(a==4&&b==0) return 0;
		for(int i=0;i<sz;i++)
			if(!judge(k,biao[i],a,b))
				biao[i--]=biao[--sz];
		if(fst&&a+b==1){
			bool vis[10]={0};
			for(int i=1;i!=10000;i*=10)
				vis[k/i%10]=true;
			k=0;
			for(int i=0,cnt=0;i<9&&cnt<4;i++)
				if(!vis[i]) k=10*k+i,cnt++;
			// printf("sz: %d\n",sz );
			printf("%04d\n",k );
			fflush(stdout);
			scanf("%d%d",&a,&b);
			if(a==4&&b==0) return 0;
			for(int i=0;i<sz;i++)
				if(!judge(k,biao[i],a,b))
					biao[i--]=biao[--sz];
			fst=false;
		}
	}
    return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <stack>
#include <vector>
#include <ctime>
#include <cstring>
#include <queue>
#define msc(X) memset(X,-1,sizeof(X))
#define ms(X) memset(X,0,sizeof(X))
typedef long long LL;
using namespace std;

int biao[5040],sz=0;
bool judge(int num,int p,int a,int b)
{
	bool vis[10]={0};
	int ca=0;
	for(int i=1;i!=10000;i*=10)
		if(num/i%10==p/i%10) ++ca;
	if(ca!=a) return false;
	for(int i=1;i!=10000;i*=10)
		vis[num/i%10]=true;
	for(int i=1;i!=10000;i*=10)
		if(vis[p/i%10]) --b;
	return a==-b;
}
int main(int argc, char const *argv[])
{
	bool fst=true;
	srand(105007);
	for(int i=0;i<10;i++)
		for(int j=0;j<10;j++)
		if(j!=i)
			for(int k=0;k<10;k++)
			if(k!=i&&k!=j)
				for(int l=0;l<10;l++)
					if(l!=i&&l!=j&&l!=k)
						biao[sz++]=1000*i+100*j+10*k+l;
	while(true){
		int k=biao[rand()%sz],a,b;
		// printf("sz: %d\n",sz );
		// if(k==9537) puts("7452");
		// else
		 printf("%04d\n", k );
		fflush(stdout);
		scanf("%d%d",&a,&b);
		if(a==4&&b==0) return 0;
		for(int i=0;i<sz;i++)
			if(!judge(k,biao[i],a,b))
				biao[i--]=biao[--sz];
		if(fst&&a+b==1){
			bool vis[10]={0};
			for(int i=1;i!=10000;i*=10)
				vis[k/i%10]=true;
			k=0;
			for(int i=0,cnt=0;i<9&&cnt<4;i++)
				if(!vis[i]) k=10*k+i,cnt++;
			// printf("sz: %d\n",sz );
			printf("%04d\n",k );
			fflush(stdout);
			scanf("%d%d",&a,&b);
			if(a==4&&b==0) return 0;
			for(int i=0;i<sz;i++)
				if(!judge(k,biao[i],a,b))
					biao[i--]=biao[--sz];
			fst=false;
		}
	}
    return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <stack>
#include <vector>
#include <ctime>
#include <cstring>
#include <queue>
#define msc(X) memset(X,-1,sizeof(X))
#define ms(X) memset(X,0,sizeof(X))
typedef long long LL;
using namespace std;

int biao[5040],sz=0;
bool judge(int num,int p,int a,int b)
{
	bool vis[10]={0};
	int ca=0;
	for(int i=1;i!=10000;i*=10)
		if(num/i%10==p/i%10) ++ca;
	if(ca!=a) return false;
	for(int i=1;i!=10000;i*=10)
		vis[num/i%10]=true;
	for(int i=1;i!=10000;i*=10)
		if(vis[p/i%10]) --b;
	return a==-b;
}
int main(int argc, char const *argv[])
{
	bool fst=true;
	srand(time(0));
	srand(100007+(rand()%10==0));
	for(int i=0;i<10;i++)
		for(int j=0;j<10;j++)
		if(j!=i)
			for(int k=0;k<10;k++)
			if(k!=i&&k!=j)
				for(int l=0;l<10;l++)
					if(l!=i&&l!=j&&l!=k)
						biao[sz++]=1000*i+100*j+10*k+l;
	while(true){
		int k=biao[rand()%sz],a,b;
		// printf("sz: %d\n",sz );
		// if(k==9537) puts("7452");
		// else
		 printf("%04d\n", k );
		fflush(stdout);
		scanf("%d%d",&a,&b);
		if(a==4&&b==0) return 0;
		for(int i=0;i<sz;i++)
			if(!judge(k,biao[i],a,b))
				biao[i--]=biao[--sz];
		if(fst&&a+b==1){
			bool vis[10]={0};
			for(int i=1;i!=10000;i*=10)
				vis[k/i%10]=true;
			k=0;
			for(int i=0,cnt=0;i<9&&cnt<4;i++)
				if(!vis[i]) k=10*k+i,cnt++;
			// printf("sz: %d\n",sz );
			printf("%04d\n",k );
			fflush(stdout);
			scanf("%d%d",&a,&b);
			if(a==4&&b==0) return 0;
			for(int i=0;i<sz;i++)
				if(!judge(k,biao[i],a,b))
					biao[i--]=biao[--sz];
			fst=false;
		}
	}
    return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <stack>
#include <vector>
#include <ctime>
#include <cstring>
#include <queue>
#define msc(X) memset(X,-1,sizeof(X))
#define ms(X) memset(X,0,sizeof(X))
typedef long long LL;
using namespace std;

int biao[5040],sz=0;
bool judge(int num,int p,int a,int b)
{
	bool vis[10]={0};
	int ca=0;
	for(int i=1;i!=10000;i*=10)
		if(num/i%10==p/i%10) ++ca;
	if(ca!=a) return false;
	for(int i=1;i!=10000;i*=10)
		vis[num/i%10]=true;
	for(int i=1;i!=10000;i*=10)
		if(vis[p/i%10]) --b;
	return a==-b;
}
int main(int argc, char const *argv[])
{
	bool fst=true;
	srand(time(0));
	for(int i=0;i<10;i++)
		for(int j=0;j<10;j++)
		if(j!=i)
			for(int k=0;k<10;k++)
			if(k!=i&&k!=j)
				for(int l=0;l<10;l++)
					if(l!=i&&l!=j&&l!=k)
						biao[sz++]=1000*i+100*j+10*k+l;
	while(true){
		int k=biao[rand()%sz],a,b;
		// printf("sz: %d\n",sz );
		printf("%04d\n", k );
		fflush(stdout);
		scanf("%d%d",&a,&b);
		if(a==4&&b==0) return 0;
		for(int i=0;i<sz;i++)
			if(!judge(k,biao[i],a,b))
				biao[i--]=biao[--sz];
		if(fst&&a+b==1){
			bool vis[10]={0};
			for(int i=1;i!=10000;i*=10)
				vis[k/i%10]=true;
			k=0;
			for(int i=0,cnt=0;i<9&&cnt<4;i++)
				if(!vis[i]) k=10*k+i,cnt++;
			// printf("sz:  %d\n",sz );
			printf("%04d\n",k );
			fflush(stdout);
			scanf("%d%d",&a,&b);
			if(a==4&&b==0) return 0;
			for(int i=0;i<sz;i++)
				if(!judge(k,biao[i],a,b))
					biao[i--]=biao[--sz];
			fst=false;
		}
	}
    return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <stack>
#include <vector>
#include <ctime>
#include <cstring>
#include <queue>
#define msc(X) memset(X,-1,sizeof(X))
#define ms(X) memset(X,0,sizeof(X))
typedef long long LL;
using namespace std;

int biao[5040],sz=0;
bool judge(int num,int p,int a,int b)
{
	bool vis[10]={0};
	int ca=0;
	for(int i=1;i!=10000;i*=10)
		if(num/i%10==p/i%10) ++ca;
	if(ca!=a) return false;
	for(int i=1;i!=10000;i*=10)
		vis[num/i%10]=true;
	for(int i=1;i!=10000;i*=10)
		if(vis[p/i%10]) --b;
	return a==-b;
}
int main(int argc, char const *argv[])
{
	bool fst=true;
	srand(103007);
	for(int i=0;i<10;i++)
		for(int j=0;j<10;j++)
		if(j!=i)
			for(int k=0;k<10;k++)
			if(k!=i&&k!=j)
				for(int l=0;l<10;l++)
					if(l!=i&&l!=j&&l!=k)
						biao[sz++]=1000*i+100*j+10*k+l;
	while(true){
		int k=biao[rand()%sz],a,b;
		// printf("sz: %d\n",sz );
		// if(k==9537) puts("7452");
		// else
		 printf("%04d\n", k );
		fflush(stdout);
		scanf("%d%d",&a,&b);
		if(a==4&&b==0) return 0;
		for(int i=0;i<sz;i++)
			if(!judge(k,biao[i],a,b))
				biao[i--]=biao[--sz];
		if(fst&&a+b==1){
			bool vis[10]={0};
			for(int i=1;i!=10000;i*=10)
				vis[k/i%10]=true;
			k=0;
			for(int i=0,cnt=0;i<9&&cnt<4;i++)
				if(!vis[i]) k=10*k+i,cnt++;
			// printf("sz: %d\n",sz );
			printf("%04d\n",k );
			fflush(stdout);
			scanf("%d%d",&a,&b);
			if(a==4&&b==0) return 0;
			for(int i=0;i<sz;i++)
				if(!judge(k,biao[i],a,b))
					biao[i--]=biao[--sz];
			fst=false;
		}
	}
    return 0;
}


#include <cstdlib>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <set>
#include <deque>
#include <cstring>
#include <functional>
#include <climits>
#include <list>
#include <ctime>
#include <complex>

#define F1(x,y,z) for(int x=(y);x<(z);x++)
#define F2(x,y,z) for(int x=(y);x<=(z);x++)
#define F3(x,y,z) for(int x=(y);x>(z);x--)
#define F4(x,y,z) for(int x=(y);x>=(z);x--)
#define mp make_pair
#define pb push_back
#define LL long long
#define co complex<double>
#define fi first
#define se second

#define MAX 100005
#define AMAX 1025*1005
#define MOD 1000000007

#define f(c,d) ((1<<(c))*(d))

using namespace std;

struct w{
	char x[4];
	int y;
} wt,ww[2][5040];

int n,i[2],ta,tb,tc,j=1,y[25];
char x[10000][10000];
bool v[10];

void go(int a){
	if(a==4)ww[0][i[0]++]=wt;
	else F1(b,0,10)if(!v[b]){
		v[b]=1;
		wt.x[a]=b;
		wt.y=wt.y*10+b;
		go(a+1);
		wt.y/=10;
		v[b]=0;
	}
}

int main(){
	go(0);
	F1(a,0,i[0])F1(b,0,i[0]){
		ta=tb=0;
		F1(c,0,4)F1(d,0,4)if(ww[0][a].x[c]==ww[0][b].x[d]){
			if(c==d)ta++;
			else tb++;
		}
		x[ww[0][a].y][ww[0][b].y]=ta*5+tb;
	}
	printf("0123\n");
	fflush(stdout);
	scanf("%d%d",&ta,&tb);
	ta=ta*5+tb;
	if(ta==20)return 0;
	F1(a,0,i[0])if(x[123][ww[0][a].y]==ta)ww[1][i[1]++]=ww[0][a];
	i[0]=0;
	while(1){
		ta=INT_MAX;
		F1(a,0,i[j]){
			memset(y,0,sizeof(y));
			F1(b,0,i[j]){
				y[x[ww[j][a].y][ww[j][b].y]]++;
			}
			tb=0;
			F1(b,0,17)tb=max(tb,y[b]);
			if(tb<ta)ta=tb,tc=ww[j][a].y;
		}
		printf("%04d\n",tc);
		fflush(stdout);
		scanf("%d%d",&ta,&tb);
		ta=ta*5+tb;
		if(ta==20)return 0;
		F1(a,0,i[j])if(x[tc][ww[j][a].y]==ta)ww[1-j][i[1-j]++]=ww[j][a];
		i[j]=0;
		j=1-j;
	}
	#ifdef LOCAL_PROJECT
	system("pause");
	#endif
	return 0;
}


/*  */
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#include <bitset>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <cctype>
#include <cassert>
#include <functional>
#include <iterator>
#include <iomanip>
using namespace std;
//#pragma comment(linker,"/STACK:102400000,1024000")

#define sti				set<int>
#define stpii			set<pair<int, int> >
#define mpii			map<int,int>
#define vi				vector<int>
#define pii				pair<int,int>
#define vpii			vector<pair<int,int> >
#define rep(i, a, n) 	for (int i=a;i<n;++i)
#define per(i, a, n) 	for (int i=n-1;i>=a;--i)
#define clr				clear
#define pb 				push_back
#define mp 				make_pair
#define fir				first
#define sec				second
#define all(x) 			(x).begin(),(x).end()
#define SZ(x) 			((int)(x).size())
#define lson			l, mid, rt<<1
#define rson			mid+1, r, rt<<1|1
#define getBits(x)		__builtin_popcount(x)
#define getBitIdx(x)	__builtin_ffs(x)

typedef long long LL;
const int maxn = 10*9*8*7+15;
int ID[maxn];
int X[maxn], nx = 0;
bool visit[10];

pii diff(int x, int y) {
	int c = 0, d = 0;
	int a[4], b[4];

	rep(k, 0, 4) {
		a[k] = x % 10;
		b[k] = y % 10;
		visit[a[k]] = true;
		if (a[k] == b[k]) ++c;
		x /= 10;
		y /= 10;
	}

	rep(k, 0, 4) {
		if (b[k] == a[k]) continue;
		if (visit[b[k]]) ++d;
	}
	rep(k, 0, 4) visit[a[k]] = false;

	return mp(c, d);
}

void init() {
	int a[4];
	bool visit[10];

	for (int i=0; i<10000; ++i) {
		memset(visit, false, sizeof(visit));
		a[0] = i%10;
		visit[a[0]] = true;

		a[1] = i/10%10;
		if (visit[a[1]]) continue;
		visit[a[1]] = true;

		a[2] = i/100%10;
		if (visit[a[2]]) continue;
		visit[a[2]] = true;

		a[3] = i/1000%10;
		if (visit[a[3]]) continue;
		visit[a[3]] = true;

		// ID[i] = nx;
		X[nx++] = i;
	}
}

int calc(int val) {
	int cnt[5][5];

	memset(cnt, 0, sizeof(cnt));
	rep(i, 0, nx) {
		pii p = diff(X[i], val);
		++cnt[p.fir][p.sec];
	}

	int ret = 0;
	rep(i, 0, 5) {
		rep(j, 0, 5) {
			ret = max(ret, cnt[i][j]);
		}
	}

	return ret;
}

void update(int c, int d, int val) {
	int m = 0;

	rep(i, 0, nx) {
		pii p = diff(X[i], val);
		if (p.fir==c && p.sec==d) {
			X[m] = X[i];
			// ID[X[m]] = m;
			++m;
		}
	}

	nx = m;
}

int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	#ifndef ONLINE_JUDGE
		freopen("data.in", "r", stdin);
		freopen("data.out", "w", stdout);
	#endif

	init();
	rep(i, 0, 7) {
		#ifndef ONLINE_JUDGE
		printf("nx = %d\n", nx);
		#endif

		int mn = INT_MAX, val = 0, tmp;
		rep(j, 0, nx) {
			tmp = calc(X[j]);
			if (tmp < mn) {
				val = X[j];
				mn = tmp;
			}
		}

		printf("%04d\n", val);
		fflush(stdout);
		int c, d;

		scanf("%d%d", &c,&d);
		if (c == 4) return 0;

		update(c, d, val);
	}

	#ifndef ONLINE_JUDGE
		printf("time = %ldms.\n", clock());
	#endif

	return 0;
}


/*  */
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#include <bitset>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <cctype>
#include <cassert>
#include <functional>
#include <iterator>
#include <iomanip>
using namespace std;
//#pragma comment(linker,"/STACK:102400000,1024000")

#define sti				set<int>
#define stpii			set<pair<int, int> >
#define mpii			map<int,int>
#define vi				vector<int>
#define pii				pair<int,int>
#define vpii			vector<pair<int,int> >
#define rep(i, a, n) 	for (int i=a;i<n;++i)
#define per(i, a, n) 	for (int i=n-1;i>=a;--i)
#define clr				clear
#define pb 				push_back
#define mp 				make_pair
#define fir				first
#define sec				second
#define all(x) 			(x).begin(),(x).end()
#define SZ(x) 			((int)(x).size())
#define lson			l, mid, rt<<1
#define rson			mid+1, r, rt<<1|1
#define getBits(x)		__builtin_popcount(x)
#define getBitIdx(x)	__builtin_ffs(x)

typedef long long LL;
const int maxn = 10*9*7*7+5;
int ID[maxn];
int X[maxn], nx = 0;

pii diff(int x, int y) {
	int c = 0, d = 0;

	rep(k, 0, 4) {
		if (x%10 == y%10)
			++c;
		else
			++d;
		x /= 10;
		y /= 10;
	}

	return mp(c, d);
}

void init() {
	int a[4];
	bool visit[10];

	for (int i=0; i<10000; ++i) {
		memset(visit, false, sizeof(visit));
		a[0] = i%10;
		visit[a[0]] = true;

		a[1] = i/10%10;
		if (visit[a[1]]) continue;
		visit[a[1]] = true;

		a[2] = i/100%10;
		if (visit[a[2]]) continue;
		visit[a[2]] = true;

		a[3] = i/1000%10;
		if (visit[a[3]]) continue;
		visit[a[3]] = true;

		ID[i] = nx;
		X[nx++] = i;
	}
}

int calc(int val) {
	int cnt[5][5];

	memset(cnt, 0, sizeof(cnt));
	rep(i, 0, nx) {
		pii p = diff(X[i], val);
		++cnt[p.fir][p.sec];
	}

	int ret = 0;
	rep(i, 0, 5) {
		rep(j, 0, 5) {
			ret = max(ret, cnt[i][j]);
		}
	}

	return ret;
}

void update(int c, int d, int val) {
	int m = 0;

	rep(i, 0, nx) {
		pii p = diff(X[i], val);
		if (p.fir==c && p.sec==d) {
			X[m] = X[i];
			ID[X[m]] = m;
			++m;
		}
	}

	nx = m;
}

int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	#ifndef ONLINE_JUDGE
		freopen("data.in", "r", stdin);
		freopen("data.out", "w", stdout);
	#endif

	init();
	rep(i, 0, 7) {
		int mn = INT_MAX, val = -1, tmp;
		rep(j, 0, nx) {
			tmp = calc(X[j]);
			if (tmp < mn) {
				val = X[j];
				mn = tmp;
			}
		}

		printf("%04d\n", val);
		fflush(stdout);
		int c, d;

		scanf("%d%d", &c,&d);
		if (c == 4) return 0;

		update(c, d, val);
	}

	#ifndef ONLINE_JUDGE
		printf("time = %ldms.\n", clock());
	#endif

	return 0;
}


/*  */
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#include <bitset>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <cctype>
#include <cassert>
#include <functional>
#include <iterator>
#include <iomanip>
using namespace std;
//#pragma comment(linker,"/STACK:102400000,1024000")

#define sti				set<int>
#define stpii			set<pair<int, int> >
#define mpii			map<int,int>
#define vi				vector<int>
#define pii				pair<int,int>
#define vpii			vector<pair<int,int> >
#define rep(i, a, n) 	for (int i=a;i<n;++i)
#define per(i, a, n) 	for (int i=n-1;i>=a;--i)
#define clr				clear
#define pb 				push_back
#define mp 				make_pair
#define fir				first
#define sec				second
#define all(x) 			(x).begin(),(x).end()
#define SZ(x) 			((int)(x).size())
#define lson			l, mid, rt<<1
#define rson			mid+1, r, rt<<1|1
#define getBits(x)		__builtin_popcount(x)
#define getBitIdx(x)	__builtin_ffs(x)

typedef long long LL;
const int maxn = 10*9*8*7+15;
int ID[maxn];
int X[maxn], nx = 0;

pii diff(int x, int y) {
	int c = 0, d = 0;

	rep(k, 0, 4) {
		if (x%10 == y%10)
			++c;
		else
			++d;
		x /= 10;
		y /= 10;
	}

	return mp(c, d);
}

void init() {
	int a[4];
	bool visit[10];

	for (int i=0; i<10000; ++i) {
		memset(visit, false, sizeof(visit));
		a[0] = i%10;
		visit[a[0]] = true;

		a[1] = i/10%10;
		if (visit[a[1]]) continue;
		visit[a[1]] = true;

		a[2] = i/100%10;
		if (visit[a[2]]) continue;
		visit[a[2]] = true;

		a[3] = i/1000%10;
		if (visit[a[3]]) continue;
		visit[a[3]] = true;

		ID[i] = nx;
		X[nx++] = i;
	}
}

int calc(int val) {
	int cnt[5][5];

	memset(cnt, 0, sizeof(cnt));
	rep(i, 0, nx) {
		pii p = diff(X[i], val);
		++cnt[p.fir][p.sec];
	}

	int ret = 0;
	rep(i, 0, 5) {
		rep(j, 0, 5) {
			ret = max(ret, cnt[i][j]);
		}
	}

	return ret;
}

void update(int c, int d, int val) {
	int m = 0;

	rep(i, 0, nx) {
		pii p = diff(X[i], val);
		if (p.fir==c && p.sec==d) {
			X[m] = X[i];
			ID[X[m]] = m;
			++m;
		}
	}

	nx = m;
}

int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	#ifndef ONLINE_JUDGE
		freopen("data.in", "r", stdin);
		freopen("data.out", "w", stdout);
	#endif

	init();
	rep(i, 0, 7) {
		int mn = INT_MAX, val = -1, tmp;
		rep(j, 0, nx) {
			tmp = calc(X[j]);
			if (tmp < mn) {
				val = X[j];
				mn = tmp;
			}
		}

		printf("%04d\n", val);
		fflush(stdout);
		int c, d;

		scanf("%d%d", &c,&d);
		if (c == 4) return 0;

		update(c, d, val);
	}

	#ifndef ONLINE_JUDGE
		printf("time = %ldms.\n", clock());
	#endif

	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pii pair<int,int>
#define pb push_back
#define INF 1e8
#define MAX 105

vector<string>v;
pii query(string s){
    cout<<s<<endl;
    int b,c;
    scanf("%d%d",&b,&c);
    return make_pair(b,c);
}

int used[10];
void build(int pos,string now){
    if(pos==4){v.push_back(now); return;}
    for(int i=0;i<10;i++){
        if(used[i]) continue;
        used[i]=1;
        build(pos+1,now+(char)('0'+i));
        used[i]=0;
    }
}

pii check(string a,string b){
    pii res;
    for(int i=0;i<4;i++) res.first+=(a[i]==b[i]);
    for(int i=0;i<4;i++) used[a[i]-'0']=1;
    for(int i=0;i<4;i++) res.second+=used[b[i]-'0'];
    for(int i=0;i<4;i++) used[a[i]-'0']=0;
    res.second-=res.first;
    return res;
}

vector<string>rebuild(vector<string>v,pii res){
    vector<string>tmp;
    for(int i=1;i<v.size();i++)
        if(check(v[i],v[0])==res) tmp.push_back(v[i]);
    return tmp;
}

int main(){
    build(0,"");
    srand(2333333);
    while(1){
        random_shuffle(v.begin(),v.end());
        pii res=query(v[0]);
        if(res.first==4)break;
        v=rebuild(v,res);
    }
}


#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pii pair<int,int>
#define pb push_back
#define INF 1e8
#define MAX 105

vector<string>v;
pii query(string s){
    cout<<s<<endl;
    int b,c;
    scanf("%d%d",&b,&c);
    return make_pair(b,c);
}

int used[10];
void build(int pos,string now){
    if(pos==4){v.push_back(now); return;}
    for(int i=0;i<10;i++){
        if(used[i]) continue;
        used[i]=1;
        build(pos+1,now+(char)('0'+i));
        used[i]=0;
    }
}

pii check(string a,string b){
    pii res;
    for(int i=0;i<4;i++) res.first+=(a[i]==b[i]);
    for(int i=0;i<4;i++) used[a[i]-'0']=1;
    for(int i=0;i<4;i++) res.second+=used[b[i]-'0'];
    for(int i=0;i<4;i++) used[a[i]-'0']=0;
    res.second-=res.first;
    return res;
}

vector<string>rebuild(vector<string>v,pii res){
    vector<string>tmp;
    for(int i=1;i<v.size();i++)
        if(check(v[i],v[0])==res) tmp.push_back(v[i]);
    return tmp;
}

int main(){
    build(0,"");
    while(1){
        pii res=query(v[0]);
        if(res.first==4)break;
        v=rebuild(v,res);
    }
}


/*#include<bits/stdc++.h>
using namespace std;
#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define rep(i,a,n) for(int i=(a);i<=(n);++i)
#define dep(i,a,n) for(int i=(a);i>=(n);--i)
#define eps 1e-8
#define pi 3.1415926535897
#define sqr(x) ((x)*(x))
#define MAX(a,b) a=max(a,b)
#define MIN(a,b) a=min(a,b)
#define SZ(x) ((int)(x).size())
#define CPY(a,b) memcpy(a,b,sizeof(a))
#define CLR(a) memset(a,0,sizeof(a))
#define POSIN(x,y) (1<=(x)&&(x)<=n&&1<=(y)&&(y)<=m)
#define all(x) (x).begin(),(x).end()
#define COUT(S,x) cout<<fixed<<setprecision(x)<<S<<endl
#define buli(x) (__builtin_popcountll(x))
#define bur0(x) (__builtin_ctzll(x))
#define bul2(x) (63-__builtin_clzll(x))
#define pw(x) ((ll(1))<<(x))
#define upmo(a,b) (((a)=((a)+(b))%mo)<0?(a)+=mo:(a))
#define mmo(a,b) (((a)=1ll*(a)*(b)%mo)<0?(a)+=mo:(a))
#define y0 y0z
#define y1 y1z
#define yn ynz
#define j0 j0z
#define j1 j1z
#define jn jnz
#define tm tmz
#ifdef LOCAL
#define debug(...) fprintf(stderr, __VA_ARGS__)
#else
#define debug(...)
#endif
typedef long long ll;
typedef double lf;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<lf,lf> pff;
typedef complex<double> CD;
const int inf=0x3f3f3f3f;
const int mo=1000000007;
inline void gn(long long&x){
	int sg=1;char c;while(((c=getchar())<'0'||c>'9')&&c!='-');c=='-'?(sg=-1,x=0):(x=c-'0');
	while((c=getchar())>='0'&&c<='9')x=x*10+c-'0';x*=sg;
}
inline void gn(int&x){long long t;gn(t);x=t;}
inline void gn(unsigned long long&x){long long t;gn(t);x=t;}
inline void gn(double&x){double t;scanf("%lf",&t);x=t;}
inline void gn(long double&x){double t;scanf("%lf",&t);x=t;}
template<class T1,class T2>inline void gn(T1&r,T2&s){gn(r),gn(s);}
template<class T1,class T2,class T3>inline void gn(T1&r,T2&s,T3&t){gn(r),gn(s),gn(t);}
template<class T1,class T2,class T3,class T4>inline void gn(T1&r,T2&s,T3&t,T4&u){gn(r),gn(s),gn(t),gn(u);}
inline void gs(char *s){scanf("%s",s);}
inline void gc(char &c){while((c=getchar())>126 || c<33);}
inline void pc(char c){putchar(c);}
const int DX[]={1,0,-1,0},DY[]={0,1,0,-1};
ll powmod(ll a,ll b) {ll res=1;a%=mo;for(;b;b>>=1){if(b&1)res=res*a%mo;a=a*a%mo;}return res;}
ll powmod(ll a,ll b,ll mo) {ll res=1;a%=mo;for(;b;b>>=1){if(b&1)res=res*a%mo;a=a*a%mo;}return res;}
ll gcd(ll a,ll b) { return b?gcd(b,a%b):a;}
//*******************************************

const int N=111111,M=111111;
int l,m,n,t,C,hid;
vector<int>ans;
int diff(int x){
	int a[11];rep(i,0,9)a[i]=0;
	rep(_,1,4)a[x%10]++,x/=10;
	rep(i,0,9)if(a[i]>1)return 0;
	return 1;
}
pii f(int x,int y){
	int a[11],b[11],A[9],B[9];rep(i,0,9)a[i]=b[i]=0;
	rep(_,1,4)a[A[_]=x%10]++,x/=10;
	rep(_,1,4)b[B[_]=y%10]++,y/=10;
	pii ans=mp(0,0);
	rep(i,1,4)if(A[i]==B[i])++ans.X,--ans.Y;
	rep(i,0,9)if(a[i]&&b[i])++ans.Y;
	return ans;
}
int calc(int x){
	int a[9][9],mx=0;
	rep(i,0,4)rep(j,0,4)a[i][j]=0;
	for(auto i:ans){
		pii p=f(i,x);
		a[p.X][p.Y]++;
	}
	rep(i,0,4)rep(j,0,4)MAX(mx,a[i][j]);
	return mx;
}
int main(){
#ifdef LOCAL
	freopen("B.in","r",stdin);//freopen("B.out","w",stdout);
	srand(unsigned(time(NULL)));
	do{hid=rand()%10000;}while(!diff(hid));
	printf("%d\n",hid);
#endif
	rep(i,0,9999)if(diff(i))ans.pb(i);
	int g;
	while(SZ(ans)>1){
		int mx=inf,ps=0;
		rep(_,0,min(SZ(ans)-1,100)){
			int p=calc(ans[_]);
			if(p<mx)mx=p,ps=_;
			if(mx<p&&mx<p/2)break;
		}
		printf("%04d\n",g=ans[ps]);
		fflush(stdout);
		int p,q;
#ifdef LOCAL
		tie(p,q)=f(hid,g);
		printf("%d %d\n",p,q);
#else
		scanf("%d%d",&p,&q);
#endif
		vector<int>tmp=ans;
		ans.clear();
		for(auto x:tmp)if(f(x,g)==mp(p,q))ans.pb(x);
	}
	if(g!=ans[0])printf("%04d\n",ans[0]);
	fflush(stdout);
	return 0;
}*/
#include<bits/stdc++.h>
using namespace std;
#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define rep(i,a,n) for(int i=(a);i<=(n);++i)
#define dep(i,a,n) for(int i=(a);i>=(n);--i)
#define eps 1e-8
#define pi 3.1415926535897
#define sqr(x) ((x)*(x))
#define MAX(a,b) a=max(a,b)
#define MIN(a,b) a=min(a,b)
#define SZ(x) ((int)(x).size())
#define CPY(a,b) memcpy(a,b,sizeof(a))
#define CLR(a) memset(a,0,sizeof(a))
#define POSIN(x,y) (1<=(x)&&(x)<=n&&1<=(y)&&(y)<=m)
#define all(x) (x).begin(),(x).end()
#define COUT(S,x) cout<<fixed<<setprecision(x)<<S<<endl
#define buli(x) (__builtin_popcountll(x))
#define bur0(x) (__builtin_ctzll(x))
#define bul2(x) (63-__builtin_clzll(x))
#define pw(x) ((ll(1))<<(x))
#define upmo(a,b) (((a)=((a)+(b))%mo)<0?(a)+=mo:(a))
#define mmo(a,b) (((a)=1ll*(a)*(b)%mo)<0?(a)+=mo:(a))
#define y0 y0z
#define y1 y1z
#define yn ynz
#define j0 j0z
#define j1 j1z
#define jn jnz
#define tm tmz
#ifdef LOCAL
#define debug(...) fprintf(stderr, __VA_ARGS__)
#else
#define debug(...)
#endif
typedef long long ll;
typedef double lf;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<lf,lf> pff;
typedef complex<double> CD;
const int inf=0x3f3f3f3f;
const int mo=1000000007;
inline void gn(long long&x){
	int sg=1;char c;while(((c=getchar())<'0'||c>'9')&&c!='-');c=='-'?(sg=-1,x=0):(x=c-'0');
	while((c=getchar())>='0'&&c<='9')x=x*10+c-'0';x*=sg;
}
inline void gn(int&x){long long t;gn(t);x=t;}
inline void gn(unsigned long long&x){long long t;gn(t);x=t;}
inline void gn(double&x){double t;scanf("%lf",&t);x=t;}
inline void gn(long double&x){double t;scanf("%lf",&t);x=t;}
template<class T1,class T2>inline void gn(T1&r,T2&s){gn(r),gn(s);}
template<class T1,class T2,class T3>inline void gn(T1&r,T2&s,T3&t){gn(r),gn(s),gn(t);}
template<class T1,class T2,class T3,class T4>inline void gn(T1&r,T2&s,T3&t,T4&u){gn(r),gn(s),gn(t),gn(u);}
inline void gs(char *s){scanf("%s",s);}
inline void gc(char &c){while((c=getchar())>126 || c<33);}
inline void pc(char c){putchar(c);}
const int DX[]={1,0,-1,0},DY[]={0,1,0,-1};
ll powmod(ll a,ll b) {ll res=1;a%=mo;for(;b;b>>=1){if(b&1)res=res*a%mo;a=a*a%mo;}return res;}
ll powmod(ll a,ll b,ll mo) {ll res=1;a%=mo;for(;b;b>>=1){if(b&1)res=res*a%mo;a=a*a%mo;}return res;}
ll gcd(ll a,ll b) { return b?gcd(b,a%b):a;}
//*******************************************

const int N=111111,M=111111;
int l,m,n,t,C,hid;
vector<int>ans;
int diff(int x){
	int a[11];rep(i,0,9)a[i]=0;
	rep(_,1,4)a[x%10]++,x/=10;
	rep(i,0,9)if(a[i]>1)return 0;
	return 1;
}
pii f(int x,int y){
	int a[11],b[11],A[9],B[9];rep(i,0,9)a[i]=b[i]=0;
	rep(_,1,4)a[A[_]=x%10]++,x/=10;
	rep(_,1,4)b[B[_]=y%10]++,y/=10;
	pii ans=mp(0,0);
	rep(i,1,4)if(A[i]==B[i])++ans.X,--ans.Y;
	rep(i,0,9)if(a[i]&&b[i])++ans.Y;
	return ans;
}
int calc(int x){
	int a[9][9],mx=0;
	rep(i,0,4)rep(j,0,4)a[i][j]=0;
	for(auto i:ans){
		pii p=f(i,x);
		a[p.X][p.Y]++;
	}
	rep(i,0,4)rep(j,0,4)MAX(mx,a[i][j]);
	return mx;
}
int main(){
#ifdef LOCAL
	freopen("B.in","r",stdin);//freopen("B.out","w",stdout);
	srand(unsigned(time(NULL)));
	do{hid=rand()%10000;}while(!diff(hid));
	printf("%d\n",hid);
#endif
	rep(i,0,9999)if(diff(i))ans.pb(i);
	int g;
	while(SZ(ans)>1){
		int mx=inf,ps=0;
		rep(_,0,min(SZ(ans)-1,100)){
			int p=calc(ans[_]);
			if(p<mx)mx=p,ps=_;
			if(mx<p&&mx<p/2)break;
		}
		printf("%04d\n",g=ans[ps]);
		fflush(stdout);
		int p,q;
#ifdef LOCAL
		tie(p,q)=f(hid,g);
		printf("%d %d\n",p,q);
#else
		scanf("%d%d",&p,&q);
#endif
		vector<int>tmp=ans;
		ans.clear();
		for(auto x:tmp)if(f(x,g)==mp(p,q))ans.pb(x);
	}
	if(g!=ans[0])printf("%04d\n",ans[0]);
	fflush(stdout);
	return 0;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cassert>
using namespace std;

typedef pair<int, int> pii;

pii compare(int target[], int guess[]) {
	int x = 0;
	for(int i = 0; i < 4; ++i) {
		if(target[i] == guess[i]) ++x;
	}
	int y = 0;
	for(int i = 0; i < 4; ++i) {
		if(target[i] == guess[i]) continue;
		bool ok = false;
		for(int j = 0; j < 4; ++j) {
			if(target[i] == guess[j]) ok = true;
		}
		if(ok) ++y;
	}
	return pii(x, y);
}

int num[10000][4], cnt, left;
bool good[10000];

void gen(void) {
	for(int i = 0; i <= 9; ++i) {
		for(int j = 0; j <= 9; ++j) if(j != i) {
			for(int k = 0; k <= 9; ++k) if(k != j && k != i) {
				for(int l = 0; l <= 9; ++l) if(l != i && l != j && l != k) {
					num[cnt][0] = i;
					num[cnt][1] = j;
					num[cnt][2] = k;
					num[cnt][3] = l;
					++cnt;
				}
			}
		}
	}
	left = cnt;
	memset(good, 1, sizeof good);
}

pii query(int guess[]) {
	for(int i = 0; i < 4; ++i) putchar('0' + guess[i]);
	putchar('\n');
	fflush(stdout);
	int x, y;
	scanf("%d%d", &x, &y);
	return pii(x, y);
}

int main(void) {
	gen();
	for(int ttt = 0; ttt < 7; ++ttt) {
		int best = left, b[4], guess[4];
		for(int i = 0; i <= 9; ++i) {
			for(int j = 0; j <= 9; ++j) {
				for(int k = 0; k <= 9; ++k) {
					for(int l = 0; l <= 9; ++l) {
						guess[0] = i;
						guess[1] = j;
						guess[2] = k;
						guess[3] = l;
						int ans[4][4] = {};
						for(int id = 0; id < cnt; ++id) if(good[id]) {
							pii res = compare(num[id], guess);
							++ans[res.first][res.second];
						}
						int max_ans = 0;
						for(int x = 0; x < 4; ++x) for(int y = 0; y < 4; ++y) {
							max_ans = max(max_ans, ans[x][y]);
						}
						if(max_ans < best) {
							best = max_ans;
							memcpy(b, guess, sizeof b);
						}
					}
				}
			}
		}

		pii res = query(b);
		if(res == pii(4, 0)) return 0;
		for(int id = 0; id < cnt; ++id) if(good[id]) {
			pii res2 = compare(num[id], b);
			if(res2 != res) {
				good[id] = false;
				--left;
			}
		}

		assert(left > 0);

		if(left == 1) {
			for(int id = 0; id < cnt; ++id) if(good[id]) {
				query(num[id]);
				return 0;
			}
		}
	}

	assert(false);
	return 0;
}


#include<iostream>
#include<sstream>
#include<fstream>
#include<cstring>
#include<cmath>
#include<ctime>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<string.h>
#include<math.h>
#include<cassert>
#include<iomanip>
#include<utility>
#include<bitset>
#include<set>
#include<map>
#include<list>
#include<queue>
#include<deque>
#include<stack>
#include<vector>
#include<functional>
#include<algorithm>
//#include<memory.h>
#include<assert.h>
#include<numeric>
#include<limits.h>
using namespace std;
int ans,a[10005];
bool ok(int nw,int x,int y,int res)
{
	int a1=res%10;
	int a2=res%100/10;
	int a3=res%1000/100;
	int a4=res/1000;
	int b1=nw%10;
	int b2=nw%100/10;
	int b3=nw%1000/100;
	int b4=nw/1000;
	int xx=0,yy=0;
	if(a1==b1)xx++;
	if(a2==b2)xx++;
	if(a3==b3)xx++;
	if(a4==b4)xx++;
	bool vis[10];
	for(int i=0;i<=9;i++)vis[i]=false;
	vis[a1]=true;
	vis[a2]=true;
	vis[a3]=true;
	vis[a4]=true;
	vis[b1]=true;
	vis[b2]=true;
	vis[b3]=true;
	vis[b4]=true;
	for(int i=0;i<=9;i++)yy+=vis[i];
	yy=8-yy-xx;
	if(x==xx&&y==yy)return true;
	return false;
}
int com(int x,int y)
{
	int a1=x%10;
	int a2=x%100/10;
	int a3=x%1000/100;
	int a4=x/1000;
	int b1=y%10;
	int b2=y%100/10;
	int b3=y%1000/100;
	int b4=y/1000;
	int yy=0;
	bool vis[10];
	for(int i=0;i<=9;i++)vis[i]=false;
	vis[a1]=true;
	vis[a2]=true;
	vis[a3]=true;
	vis[a4]=true;
	vis[b1]=true;
	vis[b2]=true;
	vis[b3]=true;
	vis[b4]=true;
	for(int i=0;i<=9;i++)yy+=vis[i];
	yy=8-yy;
	return yy;
}
bool cmp(int x,int y){return com(x,ans)>=com(y,ans);}
int main()
{
	int cnt=0;
	for(int i=0;i<=9;i++)
	{
		for(int j=0;j<=9;j++)
		{
			if(j==i)continue;
			for(int k=0;k<=9;k++)
			{
				if(k==i||k==j)continue;
				for(int l=0;l<=9;l++)
				{
					if(l==i||l==j||l==k)continue;
					int aa=i*1000+j*100+k*10+l;
					a[cnt++]=aa;
				}
			}
		}
	}
	while(true)
	{
		ans=a[0];
		printf("%04d\n",ans);
		fflush(stdout);
		int x,y;
		scanf("%d%d",&x,&y);
		if(x==4)return 0;
		for(int i=0;i<cnt;i++)if(!ok(ans,x,y,a[i]))a[i--]=a[--cnt];
		sort(a,a+cnt,cmp);
	}
	return 0;
}


#include<iostream>
#include<sstream>
#include<fstream>
#include<cstring>
#include<cmath>
#include<ctime>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<string.h>
#include<math.h>
#include<cassert>
#include<iomanip>
#include<utility>
#include<bitset>
#include<set>
#include<map>
#include<list>
#include<queue>
#include<deque>
#include<stack>
#include<vector>
#include<functional>
#include<algorithm>
//#include<memory.h>
#include<assert.h>
#include<numeric>
#include<limits.h>
using namespace std;
int ans,a[10005];
bool ok(int nw,int x,int y,int res)
{
	int a1=res%10;
	int a2=res%100/10;
	int a3=res%1000/100;
	int a4=res/1000;
	int b1=nw%10;
	int b2=nw%100/10;
	int b3=nw%1000/100;
	int b4=nw/1000;
	int xx=0,yy=0;
	if(a1==b1)xx++;
	if(a2==b2)xx++;
	if(a3==b3)xx++;
	if(a4==b4)xx++;
	bool vis[10];
	for(int i=0;i<=9;i++)vis[i]=false;
	vis[a1]=true;
	vis[a2]=true;
	vis[a3]=true;
	vis[a4]=true;
	vis[b1]=true;
	vis[b2]=true;
	vis[b3]=true;
	vis[b4]=true;
	for(int i=0;i<=9;i++)yy+=vis[i];
	yy=8-yy-xx;
	if(x==xx&&y==yy)return true;
	return false;
}
int com(int x,int y)
{
	int a1=x%10;
	int a2=x%100/10;
	int a3=x%1000/100;
	int a4=x/1000;
	int b1=y%10;
	int b2=y%100/10;
	int b3=y%1000/100;
	int b4=y/1000;
	int yy=0;
	bool vis[10];
	for(int i=0;i<=9;i++)vis[i]=false;
	vis[a1]=true;
	vis[a2]=true;
	vis[a3]=true;
	vis[a4]=true;
	vis[b1]=true;
	vis[b2]=true;
	vis[b3]=true;
	vis[b4]=true;
	for(int i=0;i<=9;i++)yy+=vis[i];
	yy=8-yy;
	return yy;
}
bool cmp(int x,int y){return com(x,ans)>com(y,ans);}
int main()
{
	int cnt=0;
	for(int i=0;i<=9;i++)
	{
		for(int j=0;j<=9;j++)
		{
			if(j==i)continue;
			for(int k=0;k<=9;k++)
			{
				if(k==i||k==j)continue;
				for(int l=0;l<=9;l++)
				{
					if(l==i||l==j||l==k)continue;
					int aa=i*1000+j*100+k*10+l;
					a[cnt++]=aa;
				}
			}
		}
	}
	while(true)
	{
		ans=a[0];
		printf("%04d\n",ans);
		fflush(stdout);
		int x,y;
		scanf("%d%d",&x,&y);
		if(x==4)return 0;
		for(int i=0;i<cnt;i++)if(!ok(ans,x,y,a[i]))a[i--]=a[--cnt];
		sort(a,a+cnt,cmp);
	}
	return 0;
}


#include<iostream>
#include<sstream>
#include<fstream>
#include<cstring>
#include<cmath>
#include<ctime>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<string.h>
#include<math.h>
#include<cassert>
#include<iomanip>
#include<utility>
#include<bitset>
#include<set>
#include<map>
#include<list>
#include<queue>
#include<deque>
#include<stack>
#include<vector>
#include<functional>
#include<algorithm>
//#include<memory.h>
#include<assert.h>
#include<numeric>
#include<limits.h>
using namespace std;
int a[10005];
bool ok(int nw,int x,int y,int ans)
{
	int a1=ans%10;
	int a2=ans%100/10;
	int a3=ans%1000/100;
	int a4=ans/1000;
	int b1=nw%10;
	int b2=nw%100/10;
	int b3=nw%1000/100;
	int b4=nw/1000;
	int xx=0,yy=0;
	if(a1==b1)xx++;
	if(a2==b2)xx++;
	if(a3==b3)xx++;
	if(a4==b4)xx++;
	bool vis[10];
	for(int i=0;i<=9;i++)vis[i]=false;
	vis[a1]=true;
	vis[a2]=true;
	vis[a3]=true;
	vis[a4]=true;
	vis[b1]=true;
	vis[b2]=true;
	vis[b3]=true;
	vis[b4]=true;
	for(int i=0;i<=9;i++)yy+=vis[i];
	yy=8-yy-xx;
	if(x==xx&&y==yy)return true;
	return false;
}
int main()
{
	int cnt=0;
	for(int i=0;i<=9;i++)
	{
		for(int j=0;j<=9;j++)
		{
			if(j==i)continue;
			for(int k=0;k<=9;k++)
			{
				if(k==i||k==j)continue;
				for(int l=0;l<=9;l++)
				{
					if(l==i||l==j||l==k)continue;
					int aa=i*1000+j*100+k*10+l;
					a[cnt++]=aa;
				}
			}
		}
	}
//	cout<<cnt<<endl;
	while(true)
	{
		int ans=a[0];
		printf("%04d\n",ans);
		int x,y;
		scanf("%d%d",&x,&y);
		if(x==4)return 0;
		for(int i=0;i<cnt;i++)if(!ok(ans,x,y,a[i]))a[i--]=a[--cnt];
//		cout<<cnt<<endl;
		sort(a,a+cnt);
//		for(int i=500;i<1000;i++)cout<<a[i]<<endl;
	}
	return 0;
}


#include<iostream>
#include<sstream>
#include<fstream>
#include<cstring>
#include<cmath>
#include<ctime>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<string.h>
#include<math.h>
#include<cassert>
#include<iomanip>
#include<utility>
#include<bitset>
#include<set>
#include<map>
#include<list>
#include<queue>
#include<deque>
#include<stack>
#include<vector>
#include<functional>
#include<algorithm>
//#include<memory.h>
#include<assert.h>
#include<numeric>
#include<limits.h>
using namespace std;
int a[10005];
bool ok(int nw,int x,int y,int ans)
{
	int a1=ans%10;
	int a2=ans%100/10;
	int a3=ans%1000/100;
	int a4=ans/1000;
	int b1=nw%10;
	int b2=nw%100/10;
	int b3=nw%1000/100;
	int b4=nw/1000;
	int xx=0,yy=0;
	if(a1==b1)xx++;
	if(a2==b2)xx++;
	if(a3==b3)xx++;
	if(a4==b4)xx++;
	bool vis[10];
	for(int i=0;i<=9;i++)vis[i]=false;
	vis[a1]=true;
	vis[a2]=true;
	vis[a3]=true;
	vis[a4]=true;
	vis[b1]=true;
	vis[b2]=true;
	vis[b3]=true;
	vis[b4]=true;
	for(int i=0;i<=9;i++)yy+=vis[i];
	yy=8-yy-xx;
	if(x==xx&&y==yy)return true;
	return false;
}
int main()
{
	int cnt=0;
	for(int i=0;i<=9;i++)
	{
		for(int j=0;j<=9;j++)
		{
			if(j==i)continue;
			for(int k=0;k<=9;k++)
			{
				if(k==i||k==j)continue;
				for(int l=0;l<=9;l++)
				{
					if(l==i||l==j||l==k)continue;
					int aa=i*1000+j*100+k*10+l;
					a[cnt++]=aa;
				}
			}
		}
	}
	srand(time(0));
	int ans=123;
	while(true)
	{
		printf("%04d\n",ans);
		fflush(stdout);
		int x,y;
		scanf("%d%d",&x,&y);
		if(x==4)return 0;
		for(int i=0;i<cnt;i++)if(!ok(ans,x,y,a[i]))a[i--]=a[--cnt];
		ans=a[rand()%cnt];
	}
	return 0;
}


#include<iostream>
#include<sstream>
#include<fstream>
#include<cstring>
#include<cmath>
#include<ctime>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<string.h>
#include<math.h>
#include<cassert>
#include<iomanip>
#include<utility>
#include<bitset>
#include<set>
#include<map>
#include<list>
#include<queue>
#include<deque>
#include<stack>
#include<vector>
#include<functional>
#include<algorithm>
//#include<memory.h>
#include<assert.h>
#include<numeric>
#include<limits.h>
using namespace std;
int a[10005];
bool ok(int nw,int x,int y,int ans)
{
	int a1=ans%10;
	int a2=ans%100/10;
	int a3=ans%1000/100;
	int a4=ans/1000;
	int b1=nw%10;
	int b2=nw%100/10;
	int b3=nw%1000/100;
	int b4=nw/1000;
	int xx=0,yy=0;
	if(a1==b1)xx++;
	if(a2==b2)xx++;
	if(a3==b3)xx++;
	if(a4==b4)xx++;
	bool vis[10];
	for(int i=0;i<=9;i++)vis[i]=false;
	vis[a1]=true;
	vis[a2]=true;
	vis[a3]=true;
	vis[a4]=true;
	vis[b1]=true;
	vis[b2]=true;
	vis[b3]=true;
	vis[b4]=true;
	for(int i=0;i<=9;i++)yy+=vis[i];
	yy=8-yy-xx;
	if(x==xx&&y==yy)return true;
	return false;
}
int main()
{
	int cnt=0;
	for(int i=0;i<=9;i++)
	{
		for(int j=0;j<=9;j++)
		{
			if(j==i)continue;
			for(int k=0;k<=9;k++)
			{
				if(k==i||k==j)continue;
				for(int l=0;l<=9;l++)
				{
					if(l==i||l==j||l==k)continue;
					int aa=i*1000+j*100+k*10+l;
					a[cnt++]=aa;
				}
			}
		}
	}
	srand(time(0));
	while(true)
	{
		int ans=a[rand()%cnt];
		printf("%04d\n",ans);
		fflush(stdout);
		int x,y;
		scanf("%d%d",&x,&y);
		if(x==4)return 0;
		for(int i=0;i<cnt;i++)if(!ok(ans,x,y,a[i]))a[i--]=a[--cnt];
	}
	return 0;
}


#include<iostream>
#include<sstream>
#include<fstream>
#include<cstring>
#include<cmath>
#include<ctime>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<string.h>
#include<math.h>
#include<cassert>
#include<iomanip>
#include<utility>
#include<bitset>
#include<set>
#include<map>
#include<list>
#include<queue>
#include<deque>
#include<stack>
#include<vector>
#include<functional>
#include<algorithm>
#include<assert.h>
#include<numeric>
#include<limits.h>
using namespace std;
int ans,a[10005];
bool ok(int nw,int x,int y,int res)
{
	int a1=res%10;
	int a2=res%100/10;
	int a3=res%1000/100;
	int a4=res/1000;
	int b1=nw%10;
	int b2=nw%100/10;
	int b3=nw%1000/100;
	int b4=nw/1000;
	int xx=0,yy=0;
	if(a1==b1)xx++;
	if(a2==b2)xx++;
	if(a3==b3)xx++;
	if(a4==b4)xx++;
	bool vis[10];
	for(int i=0;i<=9;i++)vis[i]=false;
	vis[a1]=true;
	vis[a2]=true;
	vis[a3]=true;
	vis[a4]=true;
	vis[b1]=true;
	vis[b2]=true;
	vis[b3]=true;
	vis[b4]=true;
	for(int i=0;i<=9;i++)yy+=vis[i];
	yy=8-yy-xx;
	if(x==xx&&y==yy)return true;
	return false;
}
int com(int x,int y)
{
	int a1=x%10;
	int a2=x%100/10;
	int a3=x%1000/100;
	int a4=x/1000;
	int b1=y%10;
	int b2=y%100/10;
	int b3=y%1000/100;
	int b4=y/1000;
	int yy=0;
	bool vis[10];
	for(int i=0;i<=9;i++)vis[i]=false;
	vis[a1]=true;
	vis[a2]=true;
	vis[a3]=true;
	vis[a4]=true;
	vis[b1]=true;
	vis[b2]=true;
	vis[b3]=true;
	vis[b4]=true;
	for(int i=0;i<=9;i++)yy+=(vis[i]==true);
	yy=8-yy;
	return yy;
}
//bool cmp(int x,int y){return com(x,ans)>com(y,ans);}
int main()
{
	int cnt=0;
	for(int i=0;i<=9;i++)
	{
		for(int j=0;j<=9;j++)
		{
			if(j==i)continue;
			for(int k=0;k<=9;k++)
			{
				if(k==i||k==j)continue;
				for(int l=0;l<=9;l++)
				{
					if(l==i||l==j||l==k)continue;
					int aa=i*1000+j*100+k*10+l;
					a[cnt++]=aa;
				}
			}
		}
	}
	ans=123;
	while(true)
	{
//		ans=a[0];
		printf("%04d\n",ans);
		fflush(stdout);
		int x,y;
		scanf("%d%d",&x,&y);
		if(x==4)return 0;
		for(int i=0;i<cnt;i++)if(!ok(ans,x,y,a[i]))a[i--]=a[--cnt];
//		sort(a,a+cnt,cmp);
		int mn=1e9;
		for(int i=0;i<cnt;i++)
		{
			int mx=0;
			for(int j=0;j<=4;j++)
			{
				for(int k=0;k<=4;k++)
				{
					if(j+k>4)break;
					int res=cnt;
					for(int l=0;l<cnt;l++)if(!ok(a[i],j,k,a[l]))res--;
					mx=max(mx,res);
				}
			}
			if(mn>mx)
			{
				mn=mx;
				ans=a[i];
			}
		}
	}
	return 0;
}


#include<iostream>
#include<sstream>
#include<fstream>
#include<cstring>
#include<cmath>
#include<ctime>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<string.h>
#include<math.h>
#include<cassert>
#include<iomanip>
#include<utility>
#include<bitset>
#include<set>
#include<map>
#include<list>
#include<queue>
#include<deque>
#include<stack>
#include<vector>
#include<functional>
#include<algorithm>
//#include<memory.h>
#include<assert.h>
#include<numeric>
#include<limits.h>
using namespace std;
int a[10005];
bool ok(int nw,int x,int y,int ans)
{
	int a1=ans%10;
	int a2=ans%100/10;
	int a3=ans%1000/100;
	int a4=ans/1000;
	int b1=nw%10;
	int b2=nw%100/10;
	int b3=nw%1000/100;
	int b4=nw/1000;
	int xx=0,yy=0;
	if(a1==b1)xx++;
	if(a2==b2)xx++;
	if(a3==b3)xx++;
	if(a4==b4)xx++;
	bool vis[10];
	for(int i=0;i<=9;i++)vis[i]=false;
	vis[a1]=true;
	vis[a2]=true;
	vis[a3]=true;
	vis[a4]=true;
	vis[b1]=true;
	vis[b2]=true;
	vis[b3]=true;
	vis[b4]=true;
	for(int i=0;i<=9;i++)yy+=vis[i];
	yy=8-yy-xx;
	if(x==xx&&y==yy)return true;
	return false;
}
int main()
{
	int cnt=0;
	for(int i=0;i<=9;i++)
	{
		for(int j=0;j<=9;j++)
		{
			if(j==i)continue;
			for(int k=0;k<=9;k++)
			{
				if(k==i||k==j)continue;
				for(int l=0;l<=9;l++)
				{
					if(l==i||l==j||l==k)continue;
					int aa=i*1000+j*100+k*10+l;
					a[cnt++]=aa;
				}
			}
		}
	}
//	cout<<cnt<<endl;
	while(true)
	{
		int ans=a[0];
		printf("%04d\n",ans);
		fflush(stdout);
		int x,y;
		scanf("%d%d",&x,&y);
		if(x==4)return 0;
		for(int i=0;i<cnt;i++)if(!ok(ans,x,y,a[i]))a[i--]=a[--cnt];
//		cout<<cnt<<endl;
		sort(a,a+cnt);
//		for(int i=500;i<1000;i++)cout<<a[i]<<endl;
	}
	return 0;
}


#include<iostream>
#include<sstream>
#include<fstream>
#include<cstring>
#include<cmath>
#include<ctime>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<string.h>
#include<math.h>
#include<cassert>
#include<iomanip>
#include<utility>
#include<bitset>
#include<set>
#include<map>
#include<list>
#include<queue>
#include<deque>
#include<stack>
#include<vector>
#include<functional>
#include<algorithm>
//#include<memory.h>
#include<assert.h>
#include<numeric>
#include<limits.h>
using namespace std;
int a[10005];
bool ok(int nw,int x,int y,int ans)
{
	int a1=ans%10;
	int a2=ans%100/10;
	int a3=ans%1000/100;
	int a4=ans/1000;
	int b1=nw%10;
	int b2=nw%100/10;
	int b3=nw%1000/100;
	int b4=nw/1000;
	int xx=0,yy=0;
	if(a1==b1)xx++;
	if(a2==b2)xx++;
	if(a3==b3)xx++;
	if(a4==b4)xx++;
	bool vis[10];
	for(int i=0;i<=9;i++)vis[i]=false;
	vis[a1]=true;
	vis[a2]=true;
	vis[a3]=true;
	vis[a4]=true;
	vis[b1]=true;
	vis[b2]=true;
	vis[b3]=true;
	vis[b4]=true;
	for(int i=0;i<=9;i++)yy+=vis[i];
	yy=8-yy-xx;
	if(x==xx&&y==yy)return true;
	return false;
}
int main()
{
	int cnt=0;
	for(int i=0;i<=9;i++)
	{
		for(int j=0;j<=9;j++)
		{
			if(j==i)continue;
			for(int k=0;k<=9;k++)
			{
				if(k==i||k==j)continue;
				for(int l=0;l<=9;l++)
				{
					if(l==i||l==j||l==k)continue;
					int aa=i*1000+j*100+k*10+l;
					a[cnt++]=aa;
				}
			}
		}
	}
//	cout<<cnt<<endl;
	while(true)
	{
		int ans=a[0];
		printf("%04d\n",ans);
		fflush(stdout);
		int x,y;
		scanf("%d%d",&x,&y);
		if(x==4)return 0;
		for(int i=0;i<cnt;i++)if(!ok(ans,x,y,a[i]))a[i--]=a[--cnt];
	}
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
struct Q{
	int a,b,c,d;
	Q(int x,int y,int z,int w):a(x),b(y),c(z),d(w){	}
};
pair<int,int> query(Q z){
	int u,v;
	printf("%d%d%d%d\n",z.a,z.b,z.c,z.d);fflush(stdout);
	scanf("%d%d",&u,&v);
	return make_pair(u,v);
}
pair<int,int> dist(Q e,Q f){
	int bulls = 0,cows=0;
	if(e.a==f.a)bulls++;
	if(e.b==f.b)bulls++;
	if(e.c==f.c)bulls++;
	if(e.d==f.d)bulls++;
	if((e.a==f.a)||(e.a==f.b)||(e.a==f.c)||(e.a==f.d))cows++;
	if((e.b==f.a)||(e.b==f.b)||(e.b==f.c)||(e.b==f.d))cows++;
	if((e.c==f.a)||(e.c==f.b)||(e.c==f.c)||(e.c==f.d))cows++;
	if((e.d==f.a)||(e.d==f.b)||(e.d==f.c)||(e.d==f.d))cows++;
	return make_pair(bulls,cows-bulls);
}
int main(){
	srand(2333333);
	vector<Q> X;
	for(int i=0;i<10;++i)
	  for(int j=0;j<10;++j) if(i-j){
	  	for(int k=0;k<10;++k)if((i-k)&&(j-k)){
	  	  for(int l=0;l<10;++l)
			if((i-l)&&(j-l)&&(k-l)){
				Q h(i,j,k,l);
				X.push_back(h);
			}
		}
	  }

	//cout << X.size() << endl;
	int bulls=0,cows=0,k=0;
	while(bulls<4){
		random_shuffle(X.begin(),X.end());

		int R[10]={};
		for(int i=0;i<X.size();++i){
			R[X[i].c]++;
		}
		int jmax=0;
		for(int j=0;j<10;++j)
		    if(R[j]>R[jmax]){
		    	jmax=j;
			}

		int i=0;while(X[i].c != jmax)i++;
		Q V = X[i];
		//if(k%3==1)V = X[X.size()-1];
		//if(k%3==2)V = X[X.size()/2];
		pair<int,int> Z = query(V);
		bulls = Z.first;cows = Z.second;
		vector<Q> Y;

		k++;
//		printf("%d%d%d%d bulls=%d cows=%d\n",
//		    V.a,V.b,V.c,V.d,bulls,cows);
		for(int i=0;i<X.size();++i){
			pair<int,int> T=dist(V,X[i]);
			if(T.first==bulls && T.second == cows)
			  Y.push_back(X[i]);
		}
		X=Y;
		//printf("size=%d\n",X.size());
	}
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
struct Q{
	int a,b,c,d;
	Q(int x,int y,int z,int w):a(x),b(y),c(z),d(w){	}
};
pair<int,int> query(Q z){
	int u,v;
	printf("%d%d%d%d\n",z.a,z.b,z.c,z.d);fflush(stdout);
	scanf("%d%d",&u,&v);
	return make_pair(u,v);
}
pair<int,int> dist(Q e,Q f){
	int bulls = 0,cows=0;
	if(e.a==f.a)bulls++;
	if(e.b==f.b)bulls++;
	if(e.c==f.c)bulls++;
	if(e.d==f.d)bulls++;
	if((e.a==f.a)||(e.a==f.b)||(e.a==f.c)||(e.a==f.d))cows++;
	if((e.b==f.a)||(e.b==f.b)||(e.b==f.c)||(e.b==f.d))cows++;
	if((e.c==f.a)||(e.c==f.b)||(e.c==f.c)||(e.c==f.d))cows++;
	if((e.d==f.a)||(e.d==f.b)||(e.d==f.c)||(e.d==f.d))cows++;
	return make_pair(bulls,cows-bulls);
}
int main(){
	vector<Q> X;
	for(int i=0;i<10;++i)
	  for(int j=0;j<10;++j) if(i-j){
	  	for(int k=0;k<10;++k)if((i-k)&&(j-k)){
	  	  for(int l=0;l<10;++l)
			if((i-l)&&(j-l)&&(k-l)){
				Q h(i,j,k,l);
				X.push_back(h);
			}
		}
	  }

	//cout << X.size() << endl;
	int bulls=0,cows=0,k=0;
	while(bulls<4){
		random_shuffle(X.begin(),X.end());

		int R[10]={};
		for(int i=0;i<X.size();++i){
			R[X[i].c]++;
		}
		int jmax=0;
		for(int j=0;j<10;++j)
		    if(R[j]>R[jmax]){
		    	jmax=j;
			}

		int i=0;while(X[i].c != jmax)i++;
		Q V = X[i];
		//if(k%3==1)V = X[X.size()-1];
		//if(k%3==2)V = X[X.size()/2];
		pair<int,int> Z = query(V);
		bulls = Z.first;cows = Z.second;
		vector<Q> Y;

		k++;
//		printf("%d%d%d%d bulls=%d cows=%d\n",
//		    V.a,V.b,V.c,V.d,bulls,cows);
		for(int i=0;i<X.size();++i){
			pair<int,int> T=dist(V,X[i]);
			if(T.first==bulls && T.second == cows)
			  Y.push_back(X[i]);
		}
		X=Y;
		//printf("size=%d\n",X.size());
	}
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
struct Q{
	int a,b,c,d;
	Q(int x,int y,int z,int w):a(x),b(y),c(z),d(w){	}
};
pair<int,int> query(Q z){
	int u,v;
	printf("%d%d%d%d\n",z.a,z.b,z.c,z.d);fflush(stdout);
	scanf("%d%d",&u,&v);
	return make_pair(u,v);
}
pair<int,int> dist(Q e,Q f){
	int bulls = 0,cows=0;
	if(e.a==f.a)bulls++;
	if(e.b==f.b)bulls++;
	if(e.c==f.c)bulls++;
	if(e.d==f.d)bulls++;
	if((e.a==f.a)||(e.a==f.b)||(e.a==f.c)||(e.a==f.d))cows++;
	if((e.b==f.a)||(e.b==f.b)||(e.b==f.c)||(e.b==f.d))cows++;
	if((e.c==f.a)||(e.c==f.b)||(e.c==f.c)||(e.c==f.d))cows++;
	if((e.d==f.a)||(e.d==f.b)||(e.d==f.c)||(e.d==f.d))cows++;
	return make_pair(bulls,cows-bulls);
}
int main(){
	vector<Q> X;
	for(int i=0;i<10;++i)
	  for(int j=0;j<10;++j) if(i-j){
	  	for(int k=0;k<10;++k)if((i-k)&&(j-k)){
	  	  for(int l=0;l<10;++l)
			if((i-l)&&(j-l)&&(k-l)){
				Q h(i,j,k,l);
				X.push_back(h);
			}
		}
	  }

	//cout << X.size() << endl;
	int bulls=0,cows=0,k=0;
	while(bulls<4){
		random_shuffle(X.begin(),X.end());
		Q V = X[0];
//		if(k>0){
//			int R[4][11]={};
//			for(int i=0;i<X.size();++i){
//				R[0][X[i].a]++;
//				R[1][X[i].b]++;
//				R[2][X[i].c]++;
//				R[3][X[i].d]++;
//			}
//			for(int l=0;l<4;++l){
//				int imax=0,jmax=0;
//				for(int i=0;i<4;++i)
//				  for(int j=0;j<10;++j)
//				    if(R[i][j]>R[imax][jmax]){
//				    	imax=i;jmax=j;
//					}
//				R[imax][10]=jmax;
//				for(int i=0;i<4;++i)R[i][jmax]=0;
//				for(int j=0;j<10;++j)R[imax][j]=0;
//			}
//			Q h(R[0][10],R[1][10],X[0].c,X[0].d);
//			V=h;
//		}
		//if(k%3==1)V = X[X.size()-1];
		//if(k%3==2)V = X[X.size()/2];
		pair<int,int> Z = query(V);
		bulls = Z.first;cows = Z.second;
		vector<Q> Y;

		k++;
//		printf("%d%d%d%d bulls=%d cows=%d\n",
//		    V.a,V.b,V.c,V.d,bulls,cows);
		for(int i=0;i<X.size();++i){
			pair<int,int> T=dist(V,X[i]);
			if(T.first==bulls && T.second == cows)
			  Y.push_back(X[i]);
		}
		X=Y;
		//printf("size=%d\n",X.size());
	}
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
struct Q{
	int a,b,c,d;
	Q(int x,int y,int z,int w):a(x),b(y),c(z),d(w){	}
};
pair<int,int> query(Q z){
	int u,v;
	printf("%d%d%d%d\n",z.a,z.b,z.c,z.d);fflush(stdout);
	scanf("%d%d",&u,&v);
	return make_pair(u,v);
}
pair<int,int> dist(Q e,Q f){
	int bulls = 0,cows=0;
	if(e.a==f.a)bulls++;
	if(e.b==f.b)bulls++;
	if(e.c==f.c)bulls++;
	if(e.d==f.d)bulls++;
	if((e.a==f.a)||(e.a==f.b)||(e.a==f.c)||(e.a==f.d))cows++;
	if((e.b==f.a)||(e.b==f.b)||(e.b==f.c)||(e.b==f.d))cows++;
	if((e.c==f.a)||(e.c==f.b)||(e.c==f.c)||(e.c==f.d))cows++;
	if((e.d==f.a)||(e.d==f.b)||(e.d==f.c)||(e.d==f.d))cows++;
	return make_pair(bulls,cows-bulls);
}
int main(){
	srand(2333333);
	vector<Q> X;
	for(int i=0;i<10;++i)
	  for(int j=0;j<10;++j) if(i-j){
	  	for(int k=0;k<10;++k)if((i-k)&&(j-k)){
	  	  for(int l=0;l<10;++l)
			if((i-l)&&(j-l)&&(k-l)){
				Q h(i,j,k,l);
				X.push_back(h);
			}
		}
	  }

	//cout << X.size() << endl;
	int bulls=0,cows=0,k=0;
	while(bulls<4){
		random_shuffle(X.begin(),X.end());

//		int R[10]={};
//		for(int i=0;i<X.size();++i){
//			R[X[i].c]++;
//		}
//		int jmax=0;
//		for(int j=0;j<10;++j)
//		    if(R[j]>R[jmax]){
//		    	jmax=j;
//			}
//
//		int i=0;while(X[i].c != jmax)i++;
		Q V = X[0];
		//if(k%3==1)V = X[X.size()-1];
		//if(k%3==2)V = X[X.size()/2];
		pair<int,int> Z = query(V);
		bulls = Z.first;cows = Z.second;
		vector<Q> Y;

		k++;
//		printf("%d%d%d%d bulls=%d cows=%d\n",
//		    V.a,V.b,V.c,V.d,bulls,cows);
		for(int i=0;i<X.size();++i){
			pair<int,int> T=dist(V,X[i]);
			if(T.first==bulls && T.second == cows)
			  Y.push_back(X[i]);
		}
		X=Y;
		//printf("size=%d\n",X.size());
	}
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define FOR(i,s,e) for(int i = (s); i < (e); i++)
#define FOE(i,s,e) for(int i = (s); i <= (e); i++)
#define FOD(i,s,e) for(int i = (s); i >= (e); i--)
#define ll long long
#define pb push_back

int n, m, x, y, z, k, w, aa, bb, kk;
int A[9999], B[9999], BB[9999];
int a, b, c, d;
int C[5][5];
pair<int, int> p;
int ANS[5155][5155][2];
int ans, match[10005];

pair<int, int> pre_solve(int a, int b)
{
	int c = 0, d = 0;
	int D[5], E[5];
	memset(D, 0, sizeof(D));
	memset(E, 0, sizeof(E));

	D[0] = a % 10;
	D[1] = (a / 10) % 10;
	D[2] = (a / 100) % 10;
	D[3] = (a / 1000);

	E[0] = b % 10;
	E[1] = (b / 10) % 10;
	E[2] = (b / 100) % 10;
	E[3] = (b / 1000);

	FOR(i, 0, 4) if (D[i] == E[i]) c++;
	FOR(i, 0, 4) FOR(j, 0, 4) if (i != j && D[i] == E[j]) d++;

	return make_pair(c, d);
}

pair<int, int> solve(int a, int b) {
	return make_pair(ANS[match[a]][match[b]][0], ANS[match[a]][match[b]][1]);
}

int guess(int val)
{
	memset(C, 0, sizeof(C));
	FOR(i, 0, k)
	{
		p = solve(val, B[i]);
		C[p.first][p.second]++;
	}

	int x = 0;
	FOR(i, 0, 4) FOR(j, 0, 4) x = max(x, C[i][j]);
	return x;
}

void update(int aa, int bb)
{
	kk = 0;
	FOR(i, 0, k)
	{
		p = solve(y, B[i]);
		if (p.first == aa && p.second == bb) BB[kk++] = B[i];
	}
	k = kk;
	FOR(i, 0, k) B[i] = BB[i];
}

int main ()
{
//	scanf("%d", &ans);

	FOE(i, 0, 9999)
	{
		a = i % 10;
		b = (i / 10) % 10;
		c = (i / 100) % 10;
		d = (i / 1000);
		if (a != b && a != c && a != d && b != c && b != d && c != d)
		{
			match[i] = w;
			A[w++] = i;
		}
	}

	FOR(i, 0, w) FOR(j, i, w)
	{
		p = pre_solve(A[i], A[j]);
		ANS[i][j][0] = p.first;
		ANS[i][j][1] = p.second;
		ANS[j][i][0] = ANS[i][j][0];
		ANS[j][i][1] = ANS[i][j][1];
	}

	FOE(i, 0, w) B[i] = A[i];
	k = w;

	FOR(time, 0, 6)
	{
		x = 12345; y = -1;
		FOR(i, 0, k)
		{
			z = guess(B[i]);
			if (z < x) { x = z; y = B[i]; }
		}

		printf("%04d\n", y);
		fflush(stdout);
		scanf("%d %d", &aa, &bb);
	//	p = solve(y, ans);
	//	aa = p.first;
	//	bb = p.second;
	//	printf("return %d %d\n", aa, bb);
		update(aa, bb);
	}

	printf("%04d\n", B[0]);
	fflush(stdout);
	scanf("%d%d", &aa, &bb);

	return 0;
}


#include <iostream>
#include <vector>
#include <stdio.h>
#include <numeric>
#include <stack>
#include <queue>
#include <map>
#include <algorithm>
#include <cmath>
#include <set>
#include <string.h>
#define pii pair<int,int>
#define pll pair<long long, long long>
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define all(x) x.begin(), x.end()
#define sqr(x) (x)*(x)
#define rep(i,n) for (int i=0; i<int(n); i++)
#define repi(i,j,n) for (int i=j; i<int(n); i++)
using namespace std;
typedef long long ll;
const int MOD = int(1e9+7);
//const double lim = 1e-9;
const ll lim = ll(1e18);

int n,m;
vector<string> v;

void genPerm(int pos, int flag, string s){
    if (pos == 4){
        v.pb(s);
        return;
    }
    for (int i=0; i<10; i++){
        if (!(flag&(1<<i))){
            char c = i+'0';
            genPerm(pos+1, flag|(1<<i), s+c);
        }
    }
}

pii calPoint(string s, string t){
    pii res = mp(0,0);
    int flag = 0;
    for (int i=0; i<4; i++) res.fs += (s[i] == t[i]);
    for (int i=0; i<4; i++) flag |= (1<<(s[i]-'0'));
    for (int i=0; i<4; i++) if (flag&(1<<(t[i]-'0'))) res.sc++;
    res.sc -= res.fs;
    return res;
}

vector<string> reConstruct(pii res){
    vector<string> temp;
    for (int i=1; i<v.size(); i++){
        if (calPoint(v[i],v[0]) == res) temp.pb(v[i]);
    }
    return temp;
}

int main(){
//	freopen("test.inp","r",stdin);
    srand(11111);
    genPerm(0,0,"");
    while (true){
        random_shuffle(all(v));
        cout<<v[0]<<endl;
        cin>>n>>m;
        fflush(stdout);
        if (n == 4) break;
        v = reConstruct(mp(n,m));
    }
    return 0;
}


#include <iostream>
#include <vector>
#include <stdio.h>
#include <numeric>
#include <stack>
#include <queue>
#include <map>
#include <algorithm>
#include <cmath>
#include <set>
#include <string.h>
#define pii pair<int,int>
#define pll pair<long long, long long>
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define all(x) x.begin(), x.end()
#define sqr(x) (x)*(x)
#define rep(i,n) for (int i=0; i<int(n); i++)
#define repi(i,j,n) for (int i=j; i<int(n); i++)
using namespace std;
typedef long long ll;
const int MOD = int(1e9+7);
//const double lim = 1e-9;
const ll lim = ll(1e18);

int n,m;
vector<string> v;

void genPerm(int pos, int flag, string s){
    if (pos == 4){
        v.pb(s);
        return;
    }
    for (int i=0; i<10; i++){
        if (!(flag&(1<<i))){
            char c = i+'0';
            genPerm(pos+1, flag|(1<<i), s+c);
        }
    }
}

pii calPoint(string s, string t){
    pii res = mp(0,0);
    int flag = 0;
    for (int i=0; i<4; i++) res.fs += (s[i] == t[i]);
    for (int i=0; i<4; i++) flag |= (1<<(s[i]-'0'));
    for (int i=0; i<4; i++) if (flag&(1<<(t[i]-'0'))) res.sc++;
    res.sc -= res.fs;
    return res;
}

vector<string> reConstruct(pii res){
    vector<string> temp;
    for (int i=1; i<v.size(); i++){
        if (calPoint(v[i],v[0]) == res) temp.pb(v[i]);
    }
    return temp;
}

int main(){
//	freopen("test.inp","r",stdin);
    genPerm(0,0,"");
    while (true){
        random_shuffle(all(v));
        cout<<v[0]<<endl;
        cin>>n>>m;
        fflush(stdout);
        if (n == 4) break;
        v = reConstruct(mp(n,m));
    }
    return 0;
}


#include <iostream>
#include <vector>
#include <stdio.h>
#include <numeric>
#include <stack>
#include <queue>
#include <map>
#include <algorithm>
#include <cmath>
#include <set>
#include <string.h>
#define pii pair<int,int>
#define pll pair<long long, long long>
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define all(x) x.begin(), x.end()
#define sqr(x) (x)*(x)
#define rep(i,n) for (int i=0; i<int(n); i++)
#define repi(i,j,n) for (int i=j; i<int(n); i++)
using namespace std;
typedef long long ll;
const int MOD = int(1e9+7);
//const double lim = 1e-9;
const ll lim = ll(1e18);

int n,m;
vector<string> v;

void genPerm(int pos, int flag, string s){
    if (pos == 4){
        v.pb(s);
        return;
    }
    for (int i=0; i<10; i++){
        if (!(flag&(1<<i))){
            char c = i+'0';
            genPerm(pos+1, flag|(1<<i), s+c);
        }
    }
}

pii calPoint(string s, string t){
    pii res = mp(0,0);
    int flag = 0;
    for (int i=0; i<4; i++) res.fs += (s[i] == t[i]);
    for (int i=0; i<4; i++) flag |= (1<<(s[i]-'0'));
    for (int i=0; i<4; i++) if (flag&(1<<(t[i]-'0'))) res.sc++;
    res.sc -= res.fs;
    return res;
}

vector<string> reConstruct(pii res){
    vector<string> temp;
    for (int i=1; i<v.size(); i++){
        if (calPoint(v[i],v[0]) == res) temp.pb(v[i]);
    }
    return temp;
}

int main(){
//	freopen("test.inp","r",stdin);
    srand(2333333);
    genPerm(0,0,"");
    while (true){
        random_shuffle(all(v));
        cout<<v[0]<<endl;
        cin>>n>>m;
        fflush(stdout);
        if (n == 4) break;
        v = reConstruct(mp(n,m));
    }
    return 0;
}


#include <cstdio>
#include <algorithm>
#include <cstring>
#include <iostream>
typedef long long LL;
using namespace std;
const int maxn=10100;
int num[maxn], n, m;
int val[maxn];
int tmp[maxn];
int back[5][5];
int ans;

bool valid(int N)
{
	int sz[5];
	for (int i=1; i<=4; i++)
	{
		sz[i]=N%10;
		N/=10;
	}
	sort(sz+1,sz+5);
	for (int i=1; i<4; i++)
		if (sz[i]==sz[i+1])
			return false;
	return true;
}

void addAns(int X, int Y)
{
	int ti[4], tj[4];
	int x=num[X], y=val[Y];
	for (int i=0; i<4; i++)
	{
		ti[i]=x%10;
		tj[i]=y%10;
		x/=10;
		y/=10;
	}
	int l=0, r=0;
	for (int i=0; i<4; i++)
		l+=ti[i]==tj[i];
	bool use[10];
	memset(use,0,sizeof use);
	for (int i=0; i<4; i++)
		if (!use[ti[i]])
			for (int j=0; j<4; j++)
				if (ti[i]==tj[j]&&ti[i]!=tj[i]){
					r++;
					use[ti[i]]=1;
				}
	back[l][r]++;
}

int getBack(int x, int &l, int &r){
	int ti[4], tj[4];
	int y=ans;
	for (int i=0; i<4; i++)
	{
		ti[i]=x%10;
		tj[i]=y%10;
		x/=10;
		y/=10;
	}
	l=0, r=0;
	for (int i=0; i<4; i++)
		l+=ti[i]==tj[i];
	bool use[10];
	memset(use,0,sizeof use);
	for (int i=0; i<4; i++)
		if (!use[ti[i]])
			for (int j=0; j<4; j++)
				if (ti[i]==tj[j]&&ti[i]!=tj[i]){
					r++;
					use[ti[i]]=1;
				}
}

int main()
{
//	scanf("%d",&ans);
	for (int i=0; i<10000; i++)
		if (valid(i))
			num[++n]=i;
	for (int i=1; i<=n; i++)
		val[i]=num[i];
	m=n;
	int cnt=0;
	while (++cnt){
		if (m==1){
			printf("%04d\n",val[1]);
			fflush(stdout);
			break;
		}
		int nowask=-1,nowmin=0x3f3f3f3f;
		if (m!=5040){
			for (int i=1; i<=n; i++)
			{
				memset(back,0,sizeof back);
				for (int j=1; j<=m; j++)
					addAns(i,j);
				int maxPart=-1;
				for (int j=0; j<=4; j++)
					for (int k=0; k<=4; k++)
						if (back[j][k]>maxPart)
							maxPart=back[j][k];
				if (maxPart<=nowmin)
				{
					nowmin=maxPart;
					nowask=i;
				}
			}
		} else {
			nowask=1;
		}
		printf("%04d\n",num[nowask]);
		fflush(stdout);
		int ok,next;
//		getBack(num[nowask],ok,next);
		scanf("%d%d",&ok,&next);
		if (ok==4) break;
		int nowm=m;
		m=0;
		for (int i=1; i<=nowm; i++)
		{
			back[ok][next]=0;
			addAns(nowask,i);
			if (back[ok][next])
				tmp[++m]=val[i];
		}
		for (int i=1; i<=m; i++)
			val[i]=tmp[i];
	}
//	fprintf(stderr,"%d\n",cnt);
	return 0;
}


#include<cstdio>
#include<bitset>
#include<vector>
#include<algorithm>
using namespace std;
const int n=4, N=10000;

struct guess
{
    bitset<N> can;

    guess()
    {
        can.set();

        for(int i=0; i<N; i++)
            if( !valid(i) )
                can[i]=false;
    }

    static bool valid(int x)
    {
        bitset<10> u;

        for(int i=0; i<n; i++)
        {
            int d=x%10;
            x/=10;

            if( u[d] )
                return false;
            else
                u[d]=true;
        }

        return true;
    }

    int find() const
    {
        int ans=-1, cnt=N;

        for(int i=0; ans<0 || i<10; i++)
        {
            int x=0, tmp=0;

            while( !can[x] )
                x=rand()%N;

            for(int k=0; k<=n; k++)
                for(int a=0; a<=k; a++)
                    for(int b=0; a+b<=k; b++)
                    {
                        int val=0;

                        for(int j=0; j<N; j++)
                            if( can[j] && check(x, j, a, b) )
                                val++;

                        tmp=max(tmp, val);
                    }

            if( cnt>tmp )
            {
                cnt=tmp;
                ans=x;
            }
        }

        return ans;
    }

    void operator()()
    {
        for(int a=0, b; a!=n; )
        {
            int x=find();
            printf("%.*d\n", n, x);
            fflush(stdout);
            scanf("%d%d", &a, &b);

            for(int i=0; i<N; i++)
                if( can[i] && !check(i, x, a, b) )
                    can[i]=false;
        }
    }

    static bool check(int x, int y, int a, int b)
    {
        char s[n+1], t[n+1];
        sprintf(s, "%.*d", n, x);
        sprintf(t, "%.*d", n, y);
        int p=0, q=0;

        for(int i=0; i<n; i++)
            for(int j=0; j<n; j++)
                if( s[i]==t[j] )
                    (i==j ? p : q)++;

        return a==p && b==q;
    }
};

int main()
{
    guess G;
    G();
}


#include <bits\stdc++.h>
#define ll long long
#define pb push_back
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
struct sth
{
	int A,B,C,D;
	bool checkxy()
	{
		if (A==B||B==C||C==D||A==C||B==D||A==D) return false;
		else return true;
	}
	void print()
	{
		printf("%d%d%d%d\n",A,B,C,D);
		fflush(stdout);
	}
};
	vector <sth> p[2];
	int flag,A,B,C,D,maxh,minw,minh,t1,t2,p1,p2;
	int d[5][5];
int main()
{
	flag=0;
	for (int i=123;i<=9876;i++)
	{
		A=i/1000,B=i%1000/100,C=i%100/10,D=i%10;
		if (A!=B&&B!=C&&C!=D&&A!=C&&B!=D&&A!=D) p[flag].pb((sth){A,B,C,D});
	}
	while (p[flag].size()>1)
	{
		minh=1e7;
		for (int i=0;i<p[flag].size();i++)
		{
			memset(d,0,sizeof(d));
			A=p[flag][i].A,B=p[flag][i].B,C=p[flag][i].C,D=p[flag][i].D;
			for (int j=0;j<p[flag].size();j++)
			{
				#define tmp p[flag][j]
				t1=t2=0;
				if (A==tmp.A) t1++;
				else if (A==tmp.B||A==tmp.C||A==tmp.D) t2++;
				if (B==tmp.B) t1++;
				else if (B==tmp.A||B==tmp.C||B==tmp.D) t2++;
				if (C==tmp.C) t1++;
				else if (C==tmp.A||C==tmp.B||C==tmp.D) t2++;
				if (D==tmp.D) t1++;
				else if (D==tmp.A||D==tmp.B||D==tmp.C) t2++;
				#undef tmp
				d[t1][t2]++;
			}
			maxh=0;
			for (int j=0;j<=4;j++)
				for (int k=0;k<=4-j;k++)
					maxh=max(maxh,d[j][k]);
			if (maxh<minh)
			{
				minh=maxh;
				minw=i;
			}
		}
		p[flag][minw].print();
		p1=read(),p2=read();
		A=p[flag][minw].A,B=p[flag][minw].B,C=p[flag][minw].C,D=p[flag][minw].D;
		flag^=1;
		p[flag].clear();
		for (int i=0;i<p[flag^1].size();i++)
		{
			t1=t2=0;
			#define tmp p[flag^1][i]
			if (A==tmp.A) t1++;
			else if (A==tmp.B||A==tmp.C||A==tmp.D) t2++;
			if (B==tmp.B) t1++;
			else if (B==tmp.A||B==tmp.C||B==tmp.D) t2++;
			if (C==tmp.C) t1++;
			else if (C==tmp.A||C==tmp.B||C==tmp.D) t2++;
			if (D==tmp.D) t1++;
			else if (D==tmp.A||D==tmp.B||D==tmp.C) t2++;
			if (t1==p1&&t2==p2) p[flag].pb(tmp);
			#undef tmp
		}
	}
	p[flag][0].print();
	return 0;
}


#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cstring>
#define sz 10000
using namespace std;
int p[200],cnt,now,ZH,DA,vis[sz+10],b[sz];
int C;
char s[sz+10][5];
void make(int x){
	int tmp=x;
	int cnt=0;
	for(int i=0;i<4;i++){
		s[tmp][cnt++]=x%10+'0';
		x/=10;
	}
}
bool check(int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	return da==DA&&ZH==zh;
}
bool check1(int x){
	memset(p,0,sizeof(p));
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
}
int main(){
	srand(time(0));
	for(int i=0;i<sz;i++) make(i);
	cnt=0;
	for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check1(i)) b[cnt++]=i;
			else vis[i]=1;
		}
	now=rand()*rand()%cnt;
	now=b[now];
	for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
	printf("\n");
	fflush(stdout);
	while(scanf("%d%d",&ZH,&DA)&&ZH!=4){
		C++;
		cnt=0;
		for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check(i)) b[cnt++]=i;
			else vis[i]=1;
		}
		now=rand()*rand()%cnt;
		now=b[now];
		for(int i=0;i<4;i++)
		printf("%c",s[now][i]);//
		printf("\n");
		fflush(stdout);
	}
}


#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cstring>
#define sz 10000
using namespace std;
int p[200],cnt,now,ZH,DA,vis[sz+10],b[sz];
int C;
char s[sz+10][5];
void make(int x){
	int tmp=x;
	int cnt=0;
	for(int i=0;i<4;i++){
		s[tmp][cnt++]=x%10+'0';
		x/=10;
	}
}
bool check(int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	return da==DA&&ZH==zh;
}
bool check1(int x){
	memset(p,0,sizeof(p));
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
}
int main(){
	srand(time(0));
	for(int i=0;i<sz;i++) make(i);
	cnt=0;
	for(int i=0;i<sz;i++)////
		if(!vis[i]){
			if(check1(i)) b[cnt++]=i;
			else vis[i]=1;
		}
	now=rand()*rand()%cnt;
	now=b[now];
	now=1234;
	for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
	printf("\n");
	fflush(stdout);
	while(scanf("%d%d",&ZH,&DA)&&ZH!=4){
		C++;
		cnt=0;
		for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check(i)) b[cnt++]=i;
			else vis[i]=1;
		}
		now=rand()*rand()%cnt;
		now=b[now];
		if(C==1)now=8567;
		for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
		printf("\n");
		fflush(stdout);
	}
}


#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define sz 10000
using namespace std;
int p[200],cnt,now,ZH,DA,vis[sz+10],b[sz],C;
char s[sz+10][5];
struct he{
	int zh,da,p,d;
}c[sz];
void make(int x){
	int tmp=x;
	int cnt=0;
	for(int i=0;i<4;i++){
		s[tmp][3-cnt]=x%10+'0';
		cnt++;
		x/=10;
	}
}
bool check(int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	return da==DA&&ZH==zh;
}
bool check1(int x){
	memset(p,0,sizeof(p));
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
}
void work1(int p1,int now,int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	c[p1].zh+=zh;c[p1].da+=da;
	c[p1].d+=zh*2+da;
}
bool cmp(he a,he b){
	if(a.zh+a.da==b.zh+b.da){
		return a.zh>b.zh;
	}
	return a.zh+a.da>b.zh+b.da;
}
bool cmp1(he a,he b){
	return a.d<b.d;
}
void work(){
	for(int i=0;i<cnt;i++) c[i].zh=c[i].da=0,c[i].p=i;
	for(int i=0;i<cnt;i++){
		for(int j=0;j<cnt;j++)
			work1(i,b[i],b[j]);
	}
	sort(c,c+cnt,cmp1);
//	for(int i=0;i<cnt;i++) printf("%d %d %d\n",c[i].zh,c[i].da,b[c[i].p]);
	now=b[c[0].p];
//	printf("%d\n",now);
}
int main(){
	srand(time(0));
	for(int i=0;i<sz;i++) make(i);
	cnt=0;
//	printf("\n\n");
	for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check1(i)) b[cnt++]=i;
			else vis[i]=1;
		}
	now=rand()*rand()%cnt;
	now=b[now];
//	printf("%d\n",now);
	for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
	vis[now]=1;
	printf("\n");
	fflush(stdout);
	while(scanf("%d%d",&ZH,&DA)&&ZH!=4){
		C++;
		cnt=0;
		for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check(i)) {
				b[cnt++]=i;
	//			printf("%d ",i);
			}
			else vis[i]=1;
		}
		if(C>=2)work();
		else{
			now=rand()*rand()%cnt;
			now=b[now];
		}
	//	printf("\n\n");
		for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
		vis[now]=1;
		printf("\n");
		fflush(stdout);
	}
}


#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cstring>
#define sz 10000
using namespace std;
int p[200],cnt,now,ZH,DA,vis[sz+10],b[sz];
int C;
char s[sz+10][5];
void make(int x){
	int tmp=x;
	int cnt=0;
	for(int i=0;i<4;i++){
		s[tmp][cnt++]=x%10+'0';
		x/=10;
	}
}
bool check(int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	return da==DA&&ZH==zh;
}
bool check1(int x){
	memset(p,0,sizeof(p));
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
}
int main(){
	srand(time(0));
	for(int i=0;i<sz;i++) make(i);
	cnt=0;
	for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check1(i)) b[cnt++]=i;
			else vis[i]=1;
		}
	now=rand()*rand()%cnt;
	now=b[now];
	now=1234;
	for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
	printf("\n");
	fflush(stdout);
	while(scanf("%d%d",&ZH,&DA)&&ZH!=4){
		C++;
		cnt=0;
		for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check(i)) b[cnt++]=i;
			else vis[i]=1;
		}
		now=rand()*rand()%cnt;
		now=b[now];
		if(C==1)now=8567;//
		for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
		printf("\n");
		fflush(stdout);
	}
}


#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cstring>
#define sz 10000
using namespace std;
int p[200],cnt,now,ZH,DA,vis[sz+10],b[sz];
int C;
char s[sz+10][5];
void make(int x){
	int tmp=x;
	int cnt=0;
	for(int i=0;i<4;i++){
		s[tmp][cnt++]=x%10+'0';
		x/=10;
	}
}
bool check(int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	return da==DA&&ZH==zh;
}
bool check1(int x){
	memset(p,0,sizeof(p));
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
}
int main(){
	srand(time(0));
	for(int i=0;i<sz;i++) make(i);
	cnt=0;
	for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check1(i)) b[cnt++]=i;
			else vis[i]=1;
		}
	now=rand()*rand()%cnt;
	now=b[now];
	now=1234;
	for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
	printf("\n");
	fflush(stdout);
	while(scanf("%d%d",&ZH,&DA)&&ZH!=4){
		C++;
		cnt=0;////
		for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check(i)) b[cnt++]=i;
			else vis[i]=1;
		}
		now=rand()*rand()%cnt;
		now=b[now];
		if(C==1)now=8567;
		for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
		printf("\n");
		fflush(stdout);
	}
}


#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cstring>
#define sz 10000
using namespace std;
int p[200],cnt,now,ZH,DA,vis[sz+10],b[sz];
int C;
char s[sz+10][5];
void make(int x){
	int tmp=x;
	int cnt=0;
	for(int i=0;i<4;i++){
		s[tmp][cnt++]=x%10+'0';
		x/=10;
	}
}
bool check(int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	return da==DA&&ZH==zh;
}
bool check1(int x){
	memset(p,0,sizeof(p));
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
}
int main(){
	srand(time(0));
	for(int i=0;i<sz;i++) make(i);
	cnt=0;
	for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check1(i)) b[cnt++]=i;
			else vis[i]=1;
		}
	now=rand()*rand()%cnt;
	now=b[now];
	now=0123;
	for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
	printf("\n");
	fflush(stdout);
	while(scanf("%d%d",&ZH,&DA)&&ZH!=4){
		C++;
		cnt=0;
		for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check(i)) b[cnt++]=i;
			else vis[i]=1;
		}
		now=rand()*rand()%cnt;
		now=b[now];
		if(C==1)now=4567;
		for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
		printf("\n");
		fflush(stdout);
	}
}


#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cstring>
#define sz 10000
using namespace std;
int p[200],cnt,now,ZH,DA,vis[sz+10],b[sz],Da;
int C;
char s[sz+10][5];
void make(int x){
	int tmp=x;
	int cnt=0;
	for(int i=0;i<4;i++){
		s[tmp][cnt++]=x%10+'0';
		x/=10;
	}
}
bool check(int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	return da==DA&&ZH==zh;
}
bool check1(int x){
	memset(p,0,sizeof(p));
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
}
int main(){
	srand(time(0));
	for(int i=0;i<sz;i++) make(i);
	cnt=0;
	for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check1(i)) b[cnt++]=i;
			else vis[i]=1;
		}
	now=rand()*rand()%cnt;
	now=b[now];
	now=1234;
	for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
	printf("\n");
	fflush(stdout);
	while(scanf("%d%d",&ZH,&DA)&&ZH!=4){
		C++;
		cnt=0;
		for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check(i)) b[cnt++]=i;
			else vis[i]=1;
		}
		now=rand()*rand()%cnt;
		now=b[now];Da+=DA;//
		if(C==1&&DA<=1)now=8567;
		if(C==2&&Da<=3)now=3690;
		for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
		printf("\n");
		fflush(stdout);
	}
}


#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cstring>
#define sz 10000
using namespace std;
int p[200],cnt,now,ZH,DA,vis[sz+10],b[sz];
int C;
char s[sz+10][5];
void make(int x){
	int tmp=x;
	int cnt=0;
	for(int i=0;i<4;i++){
		s[tmp][cnt++]=x%10+'0';
		x/=10;
	}
}
bool check(int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;//
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	return da==DA&&ZH==zh;
}
bool check1(int x){
	memset(p,0,sizeof(p));
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
}
int main(){
	srand(time(0));
	for(int i=0;i<sz;i++) make(i);
	cnt=0;
	for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check1(i)) b[cnt++]=i;
			else vis[i]=1;
		}
	now=rand()*rand()%cnt;
	now=b[now];
	now=1234;
	for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
	printf("\n");
	fflush(stdout);
	while(scanf("%d%d",&ZH,&DA)&&ZH!=4){
		C++;
		cnt=0;
		for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check(i)) b[cnt++]=i;
			else vis[i]=1;
		}
		now=rand()*rand()%cnt;
		now=b[now];
		if(C==1)now=8567;
		for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
		printf("\n");
		fflush(stdout);
	}
}


#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cstring>
#define sz 10000
using namespace std;
int p[200],cnt,now,ZH,DA,vis[sz+10],b[sz],Da;
int C;
char s[sz+10][5];
void make(int x){
	int tmp=x;
	int cnt=0;
	for(int i=0;i<4;i++){
		s[tmp][cnt++]=x%10+'0';
		x/=10;
	}
}
bool check(int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	return da==DA&&ZH==zh;
}
bool check1(int x){
	memset(p,0,sizeof(p));
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
}
int main(){
	srand(time(0));
	for(int i=0;i<sz;i++) make(i);
	cnt=0;
	for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check1(i)) b[cnt++]=i;
			else vis[i]=1;
		}
	now=rand()*rand()%cnt;
	now=b[now];
	now=1234;
	for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
	printf("\n");
	fflush(stdout);
	while(scanf("%d%d",&ZH,&DA)&&ZH!=4){
		C++;
		cnt=0;
		for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check(i)) b[cnt++]=i;
			else vis[i]=1;
		}
		now=rand()*rand()%cnt;
		now=b[now];Da+=DA;
		if(C==1&&DA<=1)now=8567;
		if(C==2&&Da<=3)now=3690;//
		for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
		printf("\n");
		fflush(stdout);
	}
}


#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cstring>
#define sz 10000
using namespace std;
int p[200],cnt,now,ZH,DA,vis[sz+10],b[sz];
int C;
char s[sz+10][5];
void make(int x){
	int tmp=x;
	int cnt=0;
	for(int i=0;i<4;i++){
		s[tmp][cnt++]=x%10+'0';
		x/=10;
	}
}
bool check(int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	return da==DA&&ZH==zh;
}
bool check1(int x){
	memset(p,0,sizeof(p));
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
}
int main(){
	srand(time(0));
	for(int i=0;i<sz;i++) make(i);
	cnt=0;
	for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check1(i)) b[cnt++]=i;
			else vis[i]=1;
		}
	now=rand()*rand()%cnt;
	now=b[now];
	for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
	printf("\n");
	fflush(stdout);
	while(scanf("%d%d",&ZH,&DA)&&ZH!=4){
		C++;
		cnt=0;
		for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check(i)) b[cnt++]=i;
			else vis[i]=1;
		}
		now=rand()*rand()%cnt;
		now=b[now];
		for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
		printf("\n");
		fflush(stdout);//
	}
}


#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cstring>
#define sz 10000
using namespace std;
int p[200],cnt,now,ZH,DA,vis[sz+10],b[sz];
int C;
char s[sz+10][5];
void make(int x){
	int tmp=x;
	int cnt=0;
	for(int i=0;i<4;i++){
		s[tmp][cnt++]=x%10+'0';
		x/=10;
	}
}
bool check(int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	return da==DA&&ZH==zh;
}
bool check1(int x){
	memset(p,0,sizeof(p));
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
}
int main(){
	srand(time(0));
	for(int i=0;i<sz;i++) make(i);
	cnt=0;
	for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check1(i)) b[cnt++]=i;
			else vis[i]=1;
		}
	now=rand()*rand()%cnt;
	now=b[now];
	now=1234;
	for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
	printf("\n");
	fflush(stdout);
	while(scanf("%d%d",&ZH,&DA)&&ZH!=4){
		C++;
		cnt=0;
		for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check(i)) b[cnt++]=i;
			else vis[i]=1;
		}
		now=rand()*rand()%cnt;
		now=b[now];
		if(C==1)now=8567;
		for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
		printf("\n");
		fflush(stdout);//
	}
}


#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cstring>
#define sz 10000
using namespace std;
int p[200],cnt,now,ZH,DA,vis[sz+10],b[sz];
int C;
char s[sz+10][5];
void make(int x){
	int tmp=x;//
	int cnt=0;
	for(int i=0;i<4;i++){
		s[tmp][cnt++]=x%10+'0';
		x/=10;
	}
}
bool check(int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	return da==DA&&ZH==zh;
}
bool check1(int x){
	memset(p,0,sizeof(p));
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
}
int main(){
	srand(time(0));
	for(int i=0;i<sz;i++) make(i);
	cnt=0;
	for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check1(i)) b[cnt++]=i;
			else vis[i]=1;
		}
	now=rand()*rand()%cnt;
	now=b[now];
	now=1234;
	for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
	printf("\n");
	fflush(stdout);
	while(scanf("%d%d",&ZH,&DA)&&ZH!=4){
		C++;
		cnt=0;
		for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check(i)) b[cnt++]=i;
			else vis[i]=1;
		}
		now=rand()*rand()%cnt;
		now=b[now];
		if(C==1)now=8567;
		for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
		printf("\n");
		fflush(stdout);
	}
}


#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define sz 10000
using namespace std;
int p[200],cnt,now,ZH,DA,vis[sz+10],b[sz],C;
char s[sz+10][5];
struct he{
	int zh,da,p;
}c[sz];
void make(int x){
	int tmp=x;
	int cnt=0;
	for(int i=0;i<4;i++){
		s[tmp][3-cnt]=x%10+'0';
		cnt++;
		x/=10;
	}
}
bool check(int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	return da==DA&&ZH==zh;
}
bool check1(int x){
	memset(p,0,sizeof(p));
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
}
void work1(int p1,int p2,int now,int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	c[p1].zh+=zh;c[p2].da+=da;
}
bool cmp(he a,he b){
	if(a.zh+a.da==b.zh+b.da){
		return a.zh>b.zh;
	}
	return a.zh+a.da>b.zh+b.da;
}
void work(){
	for(int i=0;i<cnt;i++) c[i].zh=c[i].da=0,c[i].p=i;
	for(int i=0;i<cnt;i++){
		for(int j=0;j<cnt;j++)
			work1(i,j,b[i],b[j]);
	}
	sort(c,c+cnt,cmp);
//	for(int i=0;i<cnt;i++) printf("%d %d %d\n",c[i].zh,c[i].da,b[c[i].p]);
	now=b[c[0].p];
//	printf("%d\n",now);
}
int main(){
	srand(time(0));
	for(int i=0;i<sz;i++) make(i);
	cnt=0;
//	printf("\n\n");
	for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check1(i)) b[cnt++]=i;
			else vis[i]=1;
		}
	now=rand()*rand()%cnt;
	now=b[now];
//	printf("%d\n",now);
	for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
	vis[now]=1;
	printf("\n");
	fflush(stdout);
	while(scanf("%d%d",&ZH,&DA)&&ZH!=4){
		C++;
		cnt=0;
		for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check(i)) {
				b[cnt++]=i;
	//			printf("%d ",i);
			}
			else vis[i]=1;
		}
		if(C>=2)work();
		else{
			now=rand()*rand()%cnt;
			now=b[now];
		}
	//	printf("\n\n");
		for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
		vis[now]=1;
		printf("\n");
		fflush(stdout);
	}
}


#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cstring>
#define sz 10000
using namespace std;
int p[200],cnt,now,ZH,DA,vis[sz+10],b[sz];
int C;
char s[sz+10][5];
void make(int x){
	int tmp=x;
	int cnt=0;
	for(int i=0;i<4;i++){
		s[tmp][cnt++]=x%10+'0';
		x/=10;
	}
}
bool check(int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	return da==DA&&ZH==zh;
}
bool check1(int x){
	memset(p,0,sizeof(p));
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
}
int main(){
	srand(time(0));
	for(int i=0;i<sz;i++) make(i);
	cnt=0;
	for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check1(i)) b[cnt++]=i;
			else vis[i]=1;
		}
	now=rand()*rand()%cnt;//
	now=b[now];
	for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
	printf("\n");
	fflush(stdout);
	while(scanf("%d%d",&ZH,&DA)&&ZH!=4){
		C++;
		cnt=0;
		for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check(i)) b[cnt++]=i;
			else vis[i]=1;
		}
		now=rand()*rand()%cnt;
		now=b[now];
		for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
		printf("\n");
		fflush(stdout);
	}
}


#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cstring>
#define sz 10000
using namespace std;
int p[200],cnt,now,ZH,DA,vis[sz+10],b[sz];
int C;
char s[sz+10][5];
void make(int x){
	int tmp=x;
	int cnt=0;
	for(int i=0;i<4;i++){
		s[tmp][cnt++]=x%10+'0';
		x/=10;
	}
}
bool check(int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	return da==DA&&ZH==zh;
}
bool check1(int x){
	memset(p,0,sizeof(p));
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
}
int main(){
	srand(time(0));
	for(int i=0;i<sz;i++) make(i);
	cnt=0;
	for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check1(i)) b[cnt++]=i;
			else vis[i]=1;
		}
	now=rand()*rand()%cnt;
	now=b[now];
	now=6483;
	for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
	printf("\n");
	fflush(stdout);
	while(scanf("%d%d",&ZH,&DA)&&ZH!=4){
		C++;
		cnt=0;
		for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check(i)) b[cnt++]=i;
			else vis[i]=1;
		}
		now=rand()*rand()%cnt;
		now=b[now];
		for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
		printf("\n");
		fflush(stdout);
	}
}


#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define sz 10000
using namespace std;
int p[200],cnt,now,ZH,DA,vis[sz+10],b[sz],C;
char s[sz+10][5];
struct he{
	int zh,da,p,d;
}c[sz];
void make(int x){
	int tmp=x;
	int cnt=0;
	for(int i=0;i<4;i++){
		s[tmp][3-cnt]=x%10+'0';
		cnt++;
		x/=10;
	}
}
bool check(int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	return da==DA&&ZH==zh;
}
bool check1(int x){
	memset(p,0,sizeof(p));
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
}
void work1(int p1,int now,int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	c[p1].zh+=zh;c[p1].da+=da;
	c[p1].d+=zh*2+da;
}
bool cmp(he a,he b){
	if(a.zh+a.da==b.zh+b.da){
		return a.zh>b.zh;
	}
	return a.zh+a.da>b.zh+b.da;
}
bool cmp1(he a,he b){
	return a.d<b.d;
}
bool cmp2(he a,he b){
	if(a.zh==b.zh)
	return a.da>b.da;
	return a.zh>b.zh;
}
void work(){
	for(int i=0;i<cnt;i++) c[i].zh=c[i].da=0,c[i].p=i;
	for(int i=0;i<cnt;i++){
		for(int j=0;j<cnt;j++)
			work1(i,b[i],b[j]);
	}
	sort(c,c+cnt,cmp2);
//	for(int i=0;i<cnt;i++) printf("%d %d %d\n",c[i].zh,c[i].da,b[c[i].p]);
	now=b[c[0].p];
//	printf("%d\n",now);
}
int main(){
	srand(time(0));
	for(int i=0;i<sz;i++) make(i);
	cnt=0;
//	printf("\n\n");
	for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check1(i)) b[cnt++]=i;
			else vis[i]=1;
		}
	now=rand()*rand()%cnt;
	now=b[now];
//	printf("%d\n",now);
	for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
	vis[now]=1;
	printf("\n");
	fflush(stdout);
	while(scanf("%d%d",&ZH,&DA)&&ZH!=4){
		C++;
		cnt=0;
		for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check(i)) {
				b[cnt++]=i;
	//			printf("%d ",i);
			}
			else vis[i]=1;
		}
		if(C>=2)work();
		else{
			now=rand()*rand()%cnt;
			now=b[now];
		}
	//	printf("\n\n");
		for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
		vis[now]=1;
		printf("\n");
		fflush(stdout);
	}
}


#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cstring>
#define sz 10000
using namespace std;
int p[200],cnt,now,ZH,DA,vis[sz+10],b[sz];
int C;
char s[sz+10][5];
void make(int x){
	int tmp=x;
	int cnt=0;
	for(int i=0;i<4;i++){
		s[tmp][cnt++]=x%10+'0';
		x/=10;
	}
}
bool check(int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	return da==DA&&ZH==zh;
}
bool check1(int x){
	memset(p,0,sizeof(p));
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
}
int main(){
	srand(time(0));
	for(int i=0;i<sz;i++) make(i);
	cnt=0;
	for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check1(i)) b[cnt++]=i;
			else vis[i]=1;
		}
	now=rand()*rand()%cnt;
	now=b[now];//1
	for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
	printf("\n");
	fflush(stdout);
	while(scanf("%d%d",&ZH,&DA)&&ZH!=4){
		C++;
		cnt=0;
		for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check(i)) b[cnt++]=i;
			else vis[i]=1;
		}
		now=rand()*rand()%cnt;
		now=b[now];
		for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
		printf("\n");
		fflush(stdout);
	}
}


#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define sz 10000
using namespace std;
int p[200],cnt,now,ZH,DA,vis[sz+10],b[sz];
char s[sz+10][5];
struct he{
	int zh,da,p;
}c[sz];
void make(int x){
	int tmp=x;
	int cnt=0;
	for(int i=0;i<4;i++){
		s[tmp][3-cnt]=x%10+'0';
		cnt++;
		x/=10;
	}
}
bool check(int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	return da==DA&&ZH==zh;
}
bool check1(int x){
	memset(p,0,sizeof(p));
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
}
void work1(int now,int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	c[x].zh+=zh;c[x].da+=da;
}
bool cmp(he a,he b){
	if(a.zh+a.da==b.zh+b.da){
		return a.zh>b.zh;
	}
	return a.zh+a.da>b.zh+b.da;
}
void work(){
	for(int i=0;i<cnt;i++) c[i].zh=c[i].da=0,c[i].p=i;
	for(int i=0;i<cnt;i++){
		for(int j=0;j<cnt;j++)
			work1(b[i],b[j]);
	}
	sort(c,c+cnt,cmp);
	now=b[c[1].p];
}
int main(){
	srand(time(0));
	for(int i=0;i<sz;i++) make(i);
	cnt=0;
//	printf("\n\n");
	for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check1(i)) b[cnt++]=i;
			else vis[i]=1;
		}
	now=rand()*rand()%cnt;
	now=b[now];
//	printf("%d\n",now);
	for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
	vis[now]=1;
	printf("\n");
	fflush(stdout);
	while(scanf("%d%d",&ZH,&DA)&&ZH!=4){
		cnt=0;
		for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check(i)) {
				b[cnt++]=i;
	//			printf("%d ",i);
			}
			else vis[i]=1;
		}
		work();
//		printf("\n\n");
		for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
		vis[now]=1;
		printf("\n");
		fflush(stdout);
	}
}


#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cstring>
#define sz 10000
using namespace std;
int p[200],cnt,now,ZH,DA,vis[sz+10],b[sz];
int C;
char s[sz+10][5];
void make(int x){
	int tmp=x;
	int cnt=0;
	for(int i=0;i<4;i++){
		s[tmp][cnt++]=x%10+'0';
		x/=10;
	}
}
bool check(int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	return da==DA&&ZH==zh;
}
bool check1(int x){
	memset(p,0,sizeof(p));
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
}
int main(){
	srand(time(0));
	for(int i=0;i<sz;i++) make(i);
	cnt=0;
	for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check1(i)) b[cnt++]=i;
			else vis[i]=1;
		}
	now=rand()*rand()%cnt;
	now=b[now];
	for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
	printf("\n");
	fflush(stdout);
	while(scanf("%d%d",&ZH,&DA)&&ZH!=4){
		C++;
		cnt=0;
		for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check(i)) b[cnt++]=i;//
			else vis[i]=1;
		}
		now=rand()*rand()%cnt;
		now=b[now];
		for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
		printf("\n");
		fflush(stdout);
	}
}


#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define sz 10000
using namespace std;
int p[200],cnt,now,ZH,DA,vis[sz+10],b[sz];
char s[sz+10][5];
struct he{
	int zh,da,p;
}c[sz];
void make(int x){
	int tmp=x;
	int cnt=0;
	for(int i=0;i<4;i++){
		s[tmp][3-cnt]=x%10+'0';
		cnt++;
		x/=10;
	}
}
bool check(int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	return da==DA&&ZH==zh;
}
bool check1(int x){
	memset(p,0,sizeof(p));
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
		if(p[s[x][i]]>1) return false;
	}
}
void work1(int now,int x){
	memset(p,0,sizeof(p));
	int zh=0,da=0;
	for(int i=0;i<4;i++){
		p[s[x][i]]++;
	}
	for(int i=0;i<4;i++){
		if(p[s[now][i]]) da++;
	}
	for(int i=0;i<4;i++)
		if(s[now][i]==s[x][i]) zh++,da--;
	c[x].zh+=zh;c[x].da+=da;
}
bool cmp(he a,he b){
	if(a.zh+a.da==b.zh+b.da){
		return a.zh>b.zh;
	}
	return a.zh+a.da>b.zh+b.da;
}
void work(){
	for(int i=0;i<cnt;i++) c[i].zh=c[i].da=0,c[i].p=i;
	for(int i=0;i<cnt;i++){
		for(int j=0;j<cnt;j++)
			work1(b[i],b[j]);
	}
	sort(c,c+cnt,cmp);
	now=b[c[1].p];
}
int main(){
	srand(time(0));
	for(int i=0;i<sz;i++) make(i);
	cnt=0;
//	printf("\n\n");
	for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check1(i)) b[cnt++]=i;
			else vis[i]=1;
		}
	now=rand()*rand()%cnt;
	now=b[now];
//	printf("%d\n",now);
	for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
	printf("\n");
	fflush(stdout);
	while(scanf("%d%d",&ZH,&DA)&&ZH!=4){
		cnt=0;
		for(int i=0;i<sz;i++)
		if(!vis[i]){
			if(check(i)) {
				b[cnt++]=i;
		//		printf("%d ",i);
			}
			else vis[i]=1;
		}
		work();
	//	printf("\n\n");
		for(int i=0;i<4;i++)
		printf("%c",s[now][i]);
		printf("\n");
		fflush(stdout);
	}
}