import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;

public class Main {
    private static String[] S = new String[30];
    private static int[] h = new int[30];
    private static int[] b = new int[30];
    private static PCG_XSH_RR rng = new PCG_XSH_RR(System.nanoTime());

    public static void main(String[] args) {
        try {
            solve();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void solve() {
        try (Scanner in = new Scanner(System.in)) {
            ArrayList<String> candidiates = new ArrayList<>();
            for (int i = 0; i <= 99999; i++) {
                StringBuilder sb = new StringBuilder();
                int v = i;
                for (int j = 0; j < 5; j++) {
                    sb.append(v % 10);
                    v /= 10;
                }
                if (valid(sb)) {
                    candidiates.add(sb.toString());
                }
            }
            Collections.shuffle(candidiates);
            String q = candidiates.remove(0);
            for (;;) {
                System.out.println(q);
                System.out.flush();
                for (int i = 0; i < S.length; i++) {
                    h[i] = in.nextInt();
                    b[i] = in.nextInt();
                }
                if (h[0] == 5 && b[0] == 0) {
                    break;
                }
                if (h[0] == -1 && b[0] == -1) {
                    break;
                }
                if (hasSum5()) {
                    String sortQ = sort(q);
                    for (int i = candidiates.size() - 1; i >= 0; i--) {
                        String candidiate = candidiates.get(i);
                        if (sort(candidiate).equals(sortQ)) {
                            q = candidiate;
                            candidiates.remove(i);
                            break;
                        }
                    }
                } else {
                    String sortQ = sort(q);
                    for (int i = candidiates.size() - 1; i >= 0; i--) {
                        String candidiate = candidiates.get(i);
                        if (sort(candidiate).equals(sortQ)) {
                            candidiates.remove(i);
                        }
                    }
                    q = candidiates.remove(0);
                }
            }
        }
    }

    private static boolean hasSum5() {
        for (int i = 0; i < S.length; i++) {
            if (h[i] != 5 && h[i] + b[i] == 5) {
                return true;
            }
        }
        return false;
    }

    private static String sort(String s) {
        char[] cs = s.toCharArray();
        Arrays.sort(cs);
        return new String(cs);
    }

    private static boolean valid(StringBuilder sb) {
        for (int i = 0; i < sb.length(); i++) {
            for (int j = i + 1; j < sb.length(); j++) {
                if (sb.charAt(j) == sb.charAt(i)) {
                    return false;
                }
            }
        }
        return true;
    }
}

class IntSet {
    private static final int EMPTY = -1;
    private int size;
    private int[] indexToValue;
    private int[] valueToIndex;

    public IntSet(int capacity) {
        this.size = 0;
        indexToValue = new int[capacity];
        valueToIndex = new int[capacity];
        Arrays.fill(valueToIndex, EMPTY);
    }

    public boolean add(int value) {
        if (valueToIndex[value] != EMPTY) {
            return false;
        }
        indexToValue[size] = value;
        valueToIndex[value] = size;
        size++;
        return true;
    }

    public boolean remove(int value) {
        int index = indexOf(value);
        if (index == EMPTY) {
            return false;
        }
        removeByIndex(index);
        return true;
    }

    private boolean removeByIndex(int index) {
        if (size == 0) {
            return false;
        }
        assert index < size;
        size--;
        int value = indexToValue[index];
        int value2 = indexToValue[size];
        indexToValue[index] = value2;
        valueToIndex[value2] = index;
        indexToValue[size] = value;
        valueToIndex[value] = EMPTY;
        return true;
    }

    public void swap(int index, int index2) {
        assert index < size;
        assert index2 < size;
        int swap = indexToValue[index];
        indexToValue[index] = indexToValue[index2];
        indexToValue[index2] = swap;
        valueToIndex[indexToValue[index]] = index;
        valueToIndex[indexToValue[index2]] = index2;
    }

    public void swapValue(int value, int value2) {
        assert value < size;
        assert value2 < size;
        int swap = valueToIndex[value];
        valueToIndex[value] = valueToIndex[value2];
        valueToIndex[value2] = swap;
        indexToValue[valueToIndex[value]] = value;
        indexToValue[valueToIndex[value2]] = value2;
    }

    public int get(int index) {
        assert index < size;
        return indexToValue[index];
    }

    public int indexOf(int value) {
        return valueToIndex[value];
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size() <= 0;
    }

    public void clear() {
        for (; size() > 0;) {
            removeByIndex(0);
        }
    }

    public boolean contains(int value) {
        return indexOf(value) != EMPTY;
    }

    @Override
    public String toString() {
        return Arrays.toString(Arrays.copyOf(indexToValue, size()));
    }
}

class Utils {
    private Utils() {
    }

    public static final void debug(Object... o) {
        System.err.println(toString(o));
        System.err.flush();
    }

    public static final String toString(Object... o) {
        return Arrays.deepToString(o);
    }

    public static boolean isValid(int v, int min, int minUpper) {
        return v >= min && v < minUpper;
    }
}

class PCG_XSH_RR {
    private long state = 5342;

    public PCG_XSH_RR(final long state) {
        this.state = state;
    }

    public int nextInt() {
        final long oldstate = state;
        state = oldstate * 6364136223846793005L + 521L;
        final int xorshift = (int) (((oldstate >>> 18) ^ oldstate) >>> 27);
        final int rotation = (int) (oldstate >>> 59);
        return (xorshift >>> rotation) | (xorshift << (-rotation & 31));
    }

    public int nextInt(int n) {
        return (int) (n * nextDouble());
    }

    public int nextInt2(int n) {
        final int k = 16;
        final int x = (nextInt() & ((1 << k) - 1));
        return (x * n) >>> k;
    }

    public double nextDouble() {
        return (nextInt() >>> 1) * 4.6566128730773926E-10;
    }
}