//import java.util.Scanner
//http://amaya382.hatenablog.jp/entry/2017/05/15/190753

import scala.collection.Searching._
import scala.annotation.tailrec
import scala.collection.immutable.Queue
import scala.io.StdIn.readLine

class IUnionFind(val size: Int) {

  private case class Node(var parent: Option[Int], var treeSize: Int)

  private val nodes = Array.fill[Node](size)(new Node(None, 1))

  def union(t1: Int, t2: Int): IUnionFind = {
    if (t1 == t2) return this

    val root1 = root(t1)
    val root2 = root(t2)
    if (root1 == root2) return this

    val node1 = nodes(root1)
    val node2 = nodes(root2)

    if (node1.treeSize < node2.treeSize) {
      node1.parent = Some(t2)
      node2.treeSize += node1.treeSize
    } else {
      node2.parent = Some(t1)
      node1.treeSize += node2.treeSize
    }
    this
  }

  def connected(t1: Int, t2: Int): Boolean = t1 == t2 || root(t1) == root(t2)

  @tailrec
  private def root(t: Int): Int = nodes(t).parent match {
    case None => t
    case Some(p) => root(p)
  }
}


object Main {
  def solve(): Unit = {
    var minv = 0
    var maxv = Scanner.nextInt()
    val pw = new java.io.PrintWriter(System.out)
    pw.println(0)
    var prev = Scanner.next()
    while (minv + 1 < maxv && prev != "Vacant") {
      val mid = (minv + maxv) / 2: Int
      pw.println(mid)
      val next = readLine()
      if (next == "Vacant") (prev = next)
      else if (prev == next) {
        if (mid == maxv) (prev = next)
        maxv = mid
      } else {
        if (mid == minv) (prev = next)
        minv = mid
        prev = next
      }
    }
  }

  def gcd(i: Int, j: Int): Int = {
    if (i < j) (gcd(j, i)) else (if (j == 0) (i) else (gcd(j, i % j)))
  }

  def main(args: Array[String]): Unit = {
    //val sc: Scanner = new Scanner(System.in)
    //solve(sc)
    solve()
  }
}

object Scanner {
  private val buf = new Array[Byte](1024);
  private var ptr = 0;
  private var len = 0

  @inline private def isPrintableChar(c: Int): Boolean = 33 <= c && c <= 126

  @inline private def hasNextByte(): Boolean =
    if (ptr >= len) {
      ptr = 0;
      len = System.in.read(buf);
      len > 0
    } else {
      true
    }

  @inline private def hasNext(): Boolean = {
    while (hasNextByte() && !isPrintableChar(buf(ptr))) ptr += 1
    hasNextByte()
  }

  @inline private def readByte(): Byte =
    if (hasNextByte()) {
      val res = buf(ptr);
      ptr += 1;
      res
    } else {
      -1
    }

  def next(): String = {
    if (!hasNext()) ???
    val sb = new StringBuilder;
    var b = readByte()
    while (isPrintableChar(b)) {
      sb.append(b.toChar);
      b = readByte()
    }
    sb.toString
  }

  def nextInt(): Int = {
    val n = nextLong()
    if (n < Int.MinValue || Int.MaxValue < n) ???
    n.toInt
  }

  def nextLong(): Long = {
    if (!hasNext()) ???
    var minus = false;
    var b = readByte()
    if (b == '-') {
      minus = true;
      b = readByte()
    }

    def go(b: Byte, n: Long = 0): Long =
      if ('0' <= b && b <= '9') {
        go(readByte(), n * 10 + b - '0')
      }
      else if (minus) {
        -n
      } else {
        n
      }

    go(b)
  }

  def nextDouble(): Double = next.toDouble
}