Problem: Mahmoud and Ehab are in the fourth stage now.

Dr. Evil has a hidden binary string of length n. He guarantees that there is at least one '0' symbol and at least one '1' symbol in it. Now he wants Mahmoud and Ehab to find a position of any '0' symbol and any '1' symbol. In order to do this, Mahmoud and Ehab can ask Dr. Evil up to 15 questions. They tell Dr. Evil some binary string of length n, and Dr. Evil tells the Hamming distance between these two strings. Hamming distance between 2 binary strings of the same length is the number of positions in which they have different symbols. You can find the definition of Hamming distance in the notes section below.

Help Mahmoud and Ehab find these two positions.

You will get Wrong Answer verdict if 

  * Your queries doesn't satisfy interaction protocol described below. 
  * You ask strictly more than 15 questions and your program terminated after exceeding queries limit. Please note, that you can do up to 15 ask queries and one answer query. 
  * Your final answer is not correct. 

You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).

If you exceed the maximum number of queries, You should terminate with 0, In this case you'll get Wrong Answer, If you don't terminate you may receive any verdict because you'll be reading from a closed stream .

Input

The first line of input will contain a single integer n (2 ≤ n ≤ 1000) — the length of the hidden binary string.

Output

To print the final answer, print "! pos0 pos1" (without quotes), where pos0 and pos1 are positions of some '0' and some '1' in the string (the string is 1-indexed). Don't forget to flush the output after printing the answer!

Interaction

To ask a question use the format "? s" (without quotes), where s is a query string. Don't forget to flush the output after printing a query!

After each query you can read a single integer from standard input — the Hamming distance between the hidden string and the query string.

To flush the output you can use:- 

  * fflush(stdout) in C++; 
  * System.out.flush() in Java; 
  * stdout.flush() in Python; 
  * flush(output) in Pascal; 
  * See the documentation for other languages . 



Hacking.

To hack someone just print one binary string with length up to 1000, containing at least one '0' and at least one '1'.

Example

Input

3
2
1
3
2
1
0

Output

? 000
? 001
? 010
? 011
? 100
? 101
! 2 1

Note

Hamming distance definition: <https://en.wikipedia.org/wiki/Hamming_distance>

In the first test case the hidden binary string is 101, The first query is 000, so the Hamming distance is 2. In the second query the hidden string is still 101 and query is 001, so the Hamming distance is 1.

After some queries you find that symbol at position 2 is '0' and symbol at position 1 is '1', so you print "! 2 1".

Solution (in JAVA):

Solution:
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.FileNotFoundException;
import java.io.File;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
  public static void main(String[] args) {
    InputStream inputStream = System.in;
    OutputStream outputStream = System.out;
    InputReader in = new InputReader(inputStream);
    OutputWriter out = new OutputWriter(outputStream);
    D solver = new D();
    solver.solve(1, in, out);
    out.close();
  }

  static class D extends SimpleSavingChelperSolution {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
      wrapSolve(testNumber, in, out);
    }

    String build(int[][] a) {
      StringBuilder sb = new StringBuilder("? ");

      for (int[] i : a) {
        for (int j = 0; j < i[1]; j++) {
          sb.append(i[0]);
        }
      }

      return sb.toString();
    }


    public void solve(int testNumber) {
      real();


//    for (int i = 4; i < 1000; i++) {
//      StringBuilder sb = new StringBuilder();
//      for (int j = 0; j < 10; j++) {
//        sb.append(((i ^ (1 << j)) > 0) ? 1 : 0);
//      }
//
//      boolean res = play(sb.toString());
//      if (!res) {
//        out.println("WH JRH WAJK");
//        out.println(sb.toString());
//        return;
//      }
//    }
//    play("1111111111");
    }

    void real() {
      D.ChannelIn cin = new D.ChannelIn() {

        public int get() {
          return in.nextInt();
        }
      };

      D.ChannelOut cout = new D.ChannelOut() {

        public void put(String s) {
          System.out.println(s);
          System.out.flush();
        }
      };

      solve(cin, cout);
    }

    void solve(D.ChannelIn in, D.ChannelOut out) {
      int n = in.get();

      out.put(build(new int[][]{{0, n}}));
      int ans1 = in.get();
      out.put(build(new int[][]{{1, 1}, {0, n - 1}}));
      int ans2 = in.get();

      int found;
      if (ans1 < ans2) {
        found = 0;
      } else {
        found = 1;
      }
      int lookingFor = found ^ 1;

      out.put(build(new int[][]{{found, n}}));
      int base = in.get();

      int l = 1;
      int r = n;

//    System.out.println("looking for " + lookingFor);

      while (r - l > 1) {
        int m = (l + r) / 2;

        int[][] request = {
            {found, 1},
            {found, l - 1},
            {lookingFor, m - l},
            {found, r - m},
            {found, n - r},
        };
        out.put(build(request));
        int answer = in.get();

        if (answer - base == m - l) {
//        System.out.println("not here " + l + " " + m);
          l = m;
        } else {
//        System.out.println("here " + l + " " + m);
          r = m;
        }
      }


      int pos0;
      int pos1;

      if (found == 0) {
        pos0 = 0;
        pos1 = l;
      } else {
        pos1 = 0;
        pos0 = l;
      }

      out.put("! " + (pos0 + 1) + " " + (pos1 + 1));
//    System.out.flush();
    }

    interface ChannelOut {
      void put(String s);

    }

    interface ChannelIn {
      int get();

    }

  }

  static abstract class SavingChelperSolution {
    protected int testNumber;
    public InputReader in;
    public OutputWriter out;
    private OutputWriter toFile;
    private boolean local = new File("chelper.properties").exists();
    public OutputWriter debug;

    {
      if (local) {
        debug = new OutputWriter(System.out);
      } else {
        debug = new OutputWriter(new OutputStream() {

          public void write(int b) {
          }
        });
      }
    }

    public SavingChelperSolution() {
      try {
        toFile = new OutputWriter("last_test_output.txt");
      } catch (FileNotFoundException e) {
        throw new RuntimeException(e);
      }
    }

    public abstract void solve(int testNumber);

    public abstract String processOutputPreCheck(int testNumber, String output);

    public abstract String processOutputPostCheck(int testNumber, String output);

    public void wrapSolve(int testNumber, InputReader in, OutputWriter out) {
      this.testNumber = testNumber;

      ByteArrayOutputStream substituteOutContents = new ByteArrayOutputStream();
      OutputWriter substituteOut = new OutputWriter(substituteOutContents);

      this.in = in;
      this.out = substituteOut;

      solve(testNumber);
      substituteOut.flush();

      String result = substituteOutContents.toString();

      result = processOutputPreCheck(testNumber, result);
      out.print(result);
      out.flush();

      if (local) {
        debug.flush();

        result = processOutputPostCheck(testNumber, result);
        toFile.print(result);
        toFile.flush();
      }
    }

  }

  static class OutputWriter extends PrintWriter {

    public void close() {
      super.close();
    }

    public OutputWriter(String fileName) throws FileNotFoundException {
      super(fileName);
    }

    public OutputWriter(OutputStream outputStream) {
      super(outputStream);
    }

    public OutputWriter(Writer writer) {
      super(writer);
    }

  }

  static abstract class SimpleSavingChelperSolution extends SavingChelperSolution {

    public String processOutputPreCheck(int testNumber, String output) {
      return output;
    }


    public String processOutputPostCheck(int testNumber, String output) {
      return output;
    }

  }

  static class InputReader {
    private BufferedReader br;
    private StringTokenizer in;

    public InputReader(String fileName) {
      try {
        br = new BufferedReader(new FileReader(fileName));
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    }

    public InputReader(InputStream inputStream) {
      br = new BufferedReader(new InputStreamReader(inputStream));
    }

    private boolean hasMoreTokens() {
      while (in == null || !in.hasMoreTokens()) {
        String s = nextLine();
        if (s == null) {
          return false;
        }
        in = new StringTokenizer(s);
      }
      return true;
    }

    public String nextString() {
      return hasMoreTokens() ? in.nextToken() : null;
    }

    public String nextLine() {
      try {
        in = null;
        return br.readLine();
      } catch (Exception e) {
        e.printStackTrace();
        return null;
      }
    }

    public int nextInt() {
      return Integer.parseInt(nextString());
    }

  }
}