import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.StringTokenizer;
import java.lang.StringBuilder;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Random;
import java.util.HashSet;
import java.util.HashMap;

public class cie{
  /*reader template*/
  static class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
      reader = new BufferedReader(new InputStreamReader(stream), 32768);
      tokenizer = null;
    }

    public String next() {
      while (tokenizer == null || !tokenizer.hasMoreTokens()) {
        try {
          tokenizer = new StringTokenizer(reader.readLine(), " \t\n\r\f/");
        } catch (IOException e) {
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    
    public int nextInt() {
      return Integer.parseInt(next());
    }
    
  }
  
  static class Oracle{
    int d;
    int r;
    int coords[];
    int lastResult = -1;
    int queryCount = 0;

 
    
    public int query(int[] q, PrintWriter pw){
//       queryCount++;
// //       printArray(d,q,pw);
//       int max = -1;
//       for(int i=0;i<d;++i){
//         if(q[i] < 0 || q[i] > 100000){
//           System.out.println("buM");
//         }
//         max = Math.max(Math.abs(coords[i] - q[i]), max);
//       }
//       
//       if(lastResult == -1){
//         lastResult = max;
//         return 0;
//       } else {
//         if (max < lastResult){
//           lastResult = max;
// //           pw.println("result 1, max " + max);
//           return 1;
//         }
//         
//         lastResult = max;
// //         pw.println("result 0, max " + max);
//         return 0;
//       }
      return cielib.czyCieplo(q);
    }
    
    public void printPoint(PrintWriter pw){
      printArray(d, coords, pw);
    }
    public void accept(int[] arr){
//       boolean good = true;
//       for(int i=0;i<d;++i){
//         good &= (arr[i] == coords[i]);
//       }
//       return good;
      cielib.znalazlem(arr);
    }
    
  }
  
  public static void printArray(int d, int[] arr, PrintWriter pw){
    pw.print("(");
    for(int i=0;i<d-1;++i){
      pw.print(""+arr[i]+",");
    }
    pw.println(""+arr[d-1]+")");
  }
  
  private static boolean check(int d, int[] q, int r, Oracle oracle, PrintWriter pw){
    int count = 0;
    for(int i=0;i<d;++i){
      int ans1 = 0;
      if(q[i]!= r){
        q[i]++;
        oracle.query(q,pw);
        q[i]--;
        ans1= oracle.query(q,pw);
      } else {
        ans1=1;
      }
      int ans2 = 0;
      if(q[i]!= 0){
        q[i]--;
        oracle.query(q,pw);
        q[i]++;
        ans2 = oracle.query(q,pw);
      } else {
        ans2 = 1;
      }
      if(ans1 == 1 && ans2 == 1){
        count ++;
      }
    }
    if(count == d){
//       pw.println("found!");
//       printArray(d,q,pw);
//       pw.println("with " + oracle.queryCount + " queries");
//       pw.println("accepted " + oracle.accept(q));
      oracle.accept(q);
      return true;
    }
    return false;
  }
  
  public static void solve(int d, int r){
    PrintWriter pw = new PrintWriter(System.out);
    Oracle oracle = new Oracle();
//     oracle.printPoint(pw);
    /*read from lib*/
    
    
    
    
    
    int[] q = new int[d];
    int[] upBorder = new int[d];
    int[] lowBorder = new int[d];
    int set = 0;
    for(int i=0; i<d;++i){
      q[i] = r/2+1;
      upBorder[i] = r;
      lowBorder[i] = 0;
    }
        
    oracle.query(q,pw);
    HashMap<Integer, HashSet<Integer>> cache = new HashMap<Integer, HashSet<Integer>>();
    for(int i=0;i<d;++i){
      HashSet<Integer> empty = new HashSet<Integer>();
      empty.add(i);
      cache.put(i,empty);
    }
    
    while(true){
      //try find max going up
      boolean goUp = false;
      boolean foundDown = false;
//       pw.println("check up");
      HashSet<Integer> repPositionsUp = null;
      HashSet<Integer> visited = new HashSet<Integer>();
      HashSet<HashSet<Integer> >  cnt = new HashSet<HashSet<Integer> >();
      cnt.addAll(cache.values());
      if(cnt.size() > 2){
      
  //       pw.println(cache);
        int tmp[] = new int[d];
        for(int i=0;i<d;++i){
          tmp[i] = Math.min(q[i]+1, r);
        }
        oracle.query(tmp,pw);
        goUp = (oracle.query(q,pw)==1);
      } else {
        goUp = true;
      }
      if(goUp){
        int rep = -1;
        for(int i=0;i<d;++i){
          if(rep>=0 && cache.get(rep).contains(i)){
            continue;
          }
          if(visited.contains(i)){
            continue;
          } else {
            visited.addAll(cache.get(i));
          }
          if(q[i] == r){
            continue;
          }
          q[i]++;
          oracle.query(q,pw);
          q[i]--;
          if(oracle.query(q,pw)==1){
            //first maximal
            if(rep == -1){
              rep = i;
              repPositionsUp = cache.get(rep);
            } else {
              HashSet<Integer> positionsUp = cache.get(i);
              repPositionsUp.addAll(positionsUp);
              for(int j : positionsUp){
                cache.put(i, repPositionsUp);
              }
            }
          }
        }
        if(rep>=0){
          //make intervals of equal size
          int bUp = Integer.MAX_VALUE;
          int bDown = Integer.MAX_VALUE;
          for(int p : repPositionsUp){
            bUp = Math.min(bUp, upBorder[p] - q[p]);
            bDown = Math.min(bDown,  q[p] - lowBorder[p]);
          }
          
          for(int p : repPositionsUp){
            upBorder[p] = q[p] + bUp;
            lowBorder[p] = q[p] - bDown;
          }
        
          for(int p : repPositionsUp){
            upBorder[p] = q[p];
            q[p] = (lowBorder[p] + q[p])/2;
          }
        }
        boolean good = true;
        for(int i=0;i<d;++i){
          good&=(upBorder[i]-lowBorder[i] <= 1);
        }
        if(good && check(d,q,r,oracle, pw)){
          break;
        }
      }
      
      
      boolean goDown = true;
      if(cnt.size() > 2){
        goDown = true;
      } else {
        int[] tmp = new int[d];
        for(int i=0;i<d;++i){
          tmp[i] = Math.max(q[i]-1, 0);
        }
        oracle.query(tmp,pw);
        goDown = (oracle.query(q,pw)==1);
      }
      
      if(goDown){
        int rep = -1;
        HashSet<Integer> repPositionsDown = new HashSet<Integer>();
        rep = -1;
        visited = new HashSet<Integer>();
  //       pw.println("check down");  
        for(int i=0;i<d;++i){
          if(rep>=0 && cache.get(rep).contains(i)){
            continue;
          }
          if(visited.contains(i)){
            continue;
          } else {
            visited.addAll(cache.get(i));
          }
          if(q[i] == 0){
            continue;
          }
          
          q[i]--;
          oracle.query(q,pw);
          q[i]++;
          if(oracle.query(q,pw) == 1){
            //first maximal
            if(rep == -1){
              rep = i;
              repPositionsDown = cache.get(rep);
              //first in this class of abstraction
            } else {
              HashSet<Integer> positionsDown = cache.get(i);
              repPositionsDown.addAll(positionsDown);
              for(int j : positionsDown){
                cache.put(i, repPositionsDown);
              }
            }
          }
        }
        if(rep>=0){
          int bUp = Integer.MAX_VALUE;
          int bDown = Integer.MAX_VALUE;
          for(int p : repPositionsDown){
            bUp = Math.min(bUp, upBorder[p] - q[p]);
            bDown = Math.min(bDown,  q[p] - lowBorder[p]);
          }
          
          for(int p : repPositionsDown){
            upBorder[p] = q[p] + bUp;
            lowBorder[p] = q[p] - bDown;
          }
          
          for(int p : repPositionsDown){
            lowBorder[p] = q[p];
            q[p] = (upBorder[p] + q[p]+1)/2;
          }
          oracle.query(q,pw);
        }
        boolean good = true;
        for(int i=0;i<d;++i){
          good&=(upBorder[i]-lowBorder[i] <= 1);
        }
        if(good && check(d,q,r,oracle, pw)){
          break;
        }
      }
      
      
      
//        printArray(d, upBorder, pw);
//        printArray(d, q, pw);
//        printArray(d, lowBorder, pw);
    
    
    }
    pw.flush();
    pw.close();
  }
  

  public static void main(String args[]){
    InputReader reader = new InputReader(System.in);
    PrintWriter pw = new PrintWriter(System.out);
//     int d = reader.nextInt();
//     int r = reader.nextInt();
    int d = cielib.podajD();
    int r = cielib.podajR();
    solve(d, r);
  }

}