#include <bits/stdc++.h>
using namespace std;
using pii=pair<int,int>;
using tii=tuple<int,int,int>;
using qii=tuple<int,int,int,int>;
using ll=long long;
using ull=unsigned long long;
using ld=long double;
constexpr int INF=1e9;
constexpr ll INF_ll=1e18;
#define rep(i,n) for (int i=0;i<(int)(n);i++)
#define replr(i,l,r) for (int i=(int)(l);i<(int)(r);i++)
#define all(v) v.begin(),v.end()
#define len(v) ((int)v.size())
template<class T> inline bool chmin(T &a,T b){
    if(a>b){
        a=b;
        return true;
    }
    return false;
}
template<class T> inline bool chmax(T &a,T b){
    if(a<b){
        a=b;
        return true;
    }
    return false;
}

namespace Timer{
    chrono::system_clock::time_point program_start,start;
    void program_start_snap(){
        program_start=start=chrono::system_clock::now();
    }
    void snap(){
        start=chrono::system_clock::now();
    }
    int get_ms(){
        auto now=chrono::system_clock::now();
        int ms=chrono::duration_cast<chrono::milliseconds>(now-start).count();
        return ms;
    }
    int get_ms_all_program(){
        auto now=chrono::system_clock::now();
        int ms=chrono::duration_cast<chrono::milliseconds>(now-program_start).count();
        return ms;
    }
}

mt19937 mt;
uint32_t rand_int(uint32_t r){  //[0,r)
    assert(r!=0);
    return ((uint64_t)mt()*r)>>32;
}
int rand_int(int l,int r){  //[l,r)
    assert(l<r);
    return l+rand_int(r-l);
}
constexpr double one_div_mt_max=1.0/(double)mt19937::max();
double rand_double(){  //[0.0,1.0]
    return mt()*one_div_mt_max;
}

template<class T> T get_random_element(const vector<T> &v){
    assert(!v.empty());
    return v[rand_int(len(v))];
}

template<class T> void add(vector<T> &a,vector<T> b){
    for(auto i:b) a.push_back(i);
}

constexpr int N=30,K=5;

vector<string> C;

array<int,10> last_vis;

int vis_cnt=0;

pii get_hb(const string &x,const string &y){  //TODO
    int h=0,b=0;
    
    vis_cnt++;
    
    rep(k,K){
        last_vis[x[k]-'0']=vis_cnt;
    }
    
    rep(k,K){
        if(x[k]==y[k]) h++;
        else if(last_vis[y[k]-'0']==vis_cnt) b++;
    }
    
    
    return {h,b};
}


namespace Communication{
    
    vector<string> S;
    
    vector<int> finished;
    
    void init(){
        S.resize(N);
        finished.resize(N,false);
        
        auto c=C;
        
        shuffle(all(c),mt);
        
        rep(i,N){
            S[i]=c[i];
            
            cerr << "ans:" << S[i] << '\n';
        }
        
        cerr << '\n';
    }
    
    int turn=0,finished_cnt=0;
    
    vector<pii> query(string q){
        
        turn++;
        
        assert(len(q)==K);
        
        
        
        vector<pii> ret(N);
        
        #ifdef LOCAL
        
        rep(i,N){
            
            if(S[i]==q||finished[i]){
                ret[i]={5,0};
                if(!finished[i]) finished_cnt++;
                finished[i]=true;
                continue;
            }
            
            int h=0,b=0;
            rep(k,K){
                if(S[i][k]==q[k]) h++;
            }
            rep(k,K){
                rep(l,K){
                    if(k==l) continue;
                    if(S[i][k]==q[l]) b++;
                }
            }
            ret[i]={h,b};
        }
        sort(all(ret));
        
        #else
        
        cout << q << '\n';
        cout.flush();
        
        finished_cnt=0;
        
        rep(i,N){
            int h,b;
            cin >> h >> b;
            if(h==K&&b==0) finished_cnt++;
            ret[i]={h,b};
        }
        
        #endif
        
        
        
        if(ret.front()==pii{K,0}){
            cerr << "turn:" << turn << '\n';
            exit(0);
        }
        
        if(ret.front()==pii{-1,-1}) assert(0);
        
        
        return ret;
    }
};

namespace Solver{
    
    string get_best_query(const vector<string> &candidate){
        
        string best_str;
            
        int best_size=-INF;
        
        
        for(const auto &x:C){
            
            map<pii,int> mp;
            for(const auto &y:candidate){
                mp[get_hb(x,y)]++;
            }
            if(chmax(best_size,len(mp))){
                best_str=x;
            }
        }
        
        return best_str;
    }
    
    void solve(){
        
        auto c=C;
        
        constexpr int X=200;
        
        while(true){
            
            string str=get_random_element(c);
            
            if(len(c)<X) str=get_best_query(c);
            
            
            
            vector<pii> hb=Communication::query(str);
            
            set<pii> st(all(hb));
            
            st.erase({5,0});
            
            vector<string> new_c;
            
            for(const auto &x:c){
                
                if(st.contains(get_hb(str,x))){
                    new_c.push_back(x);
                }
            }
            
            int diff=len(c)-len(new_c);
            
            c=new_c;
            
            cerr << len(c) << endl;
            
            if(diff==0&&len(c)<X) break;
        }
        
        for(auto str:c){
            Communication::query(str);
        }
        
        assert(0);
        
    }
}

void init(){
    
    last_vis.fill(-1);
    
    rep(i,100000){
        string s=to_string(i);
        while(len(s)<K) s.insert(s.begin(),'0');
        string t=s;
        sort(all(t));
        t.erase(unique(all(t)),t.end());
        if(len(t)==K){
            C.push_back(s);
        }
    }
    
    #ifdef LOCAL
    
    Communication::init();
    
    #endif
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    Timer::program_start_snap();
    
    init();



    Solver::solve();
    exit(0);
}