import java.io.*;
import java.util.*;

/**
 * Solution for NEERC'2013 Problem I: Interactive Interception.
 * This solution checks correctness of the input.
 *
 * @author Roman Elizarov
 */
public class interactive_re {

    private static final int MAX_P = 100_000;
    private static final int MAX_V = 100_000;

    private static final double EPS = 1e-5;
    private static final boolean DEBUG = false;

    public static void main(String[] args) throws Exception {
        new interactive_re().go();
    }

    void go() throws Exception {
        long time = System.currentTimeMillis();
        read();
        solve();
        write();
        System.out.printf("Done in %d ms%n", System.currentTimeMillis() - time);
    }

    Scanner in;
    int p;
    int v;

    void read() throws Exception {
        in = new Scanner(System.in);
        p = in.nextInt();
        v = in.nextInt();
        assert p >= 1 && p <= MAX_P;
        assert v >= 1 && v <= MAX_V;
    }

    static class Pt implements Comparable<Pt> {
        double x;
        double q;

        Pt(double x, double q) {
            this.x = x;
            this.q = q;
        }

        @Override
        public int compareTo(Pt o) {
            return Double.compare(x, o.x);
        }

        @Override
        public String toString() {
            return String.format(Locale.US, "(%.2f,%.2f)", x, q);
        }
    }

    int answer;
    List<Pt> dn;
    List<Pt> up;
    List<Pt> pts;

    void solve() {
        dn = new ArrayList<>(Arrays.asList(new Pt(0, 0), new Pt(p, 0), new Pt(p, v)));
        up = new ArrayList<>(Arrays.asList(new Pt(0, 0), new Pt(0, v), new Pt(p, v)));
        pts = new ArrayList<>();
        while (true) {
            int L0 = (int)(dn.get(0).x + (1 - EPS));
            int R0 = (int)(dn.get(dn.size() - 1).x + EPS);
            assert L0 <= R0;
            if (L0 == R0) {
                answer = L0;
                return;
            }
            pts.clear();
            pts.addAll(up);
            pts.addAll(dn);
            Collections.sort(pts);
            Finder fAll = new Finder().find(Double.POSITIVE_INFINITY);
            Finder fMid = new Finder().find(fAll.square / 2);
            if (DEBUG) {
                System.out.println("dn=" + dn);
                System.out.println("up=" + up);
                System.out.println("mid.x=" + fMid.xt);
            }

            int M = (int)(fMid.xt + EPS);
            System.out.println("check 0 " + M);
            in.nextLine();
            String s = in.next();
            assert s.equals("Yes") || s.equals("No");
            if (s.equals("Yes")) {
                dn.subList(fMid.dnI, dn.size()).clear();
                up.subList(fMid.upI, up.size()).clear();
                dn.add(new Pt(fMid.xt, fMid.qt0));
                dn.add(new Pt(fMid.xt, fMid.qt1));
                up.add(new Pt(fMid.xt, fMid.qt1));
            } else {
                dn.subList(0, fMid.dnI).clear();
                up.subList(0, fMid.upI).clear();
                dn.add(0, new Pt(fMid.xt, fMid.qt0));
                up.add(0, new Pt(fMid.xt, fMid.qt0));
                up.add(1, new Pt(fMid.xt, fMid.qt1));
            }
            // tilt
            tilt(dn);
            tilt(up);
        }
    }

    private void tilt(List<Pt> p) {
        for (Pt pt : p)
            pt.x += pt.q;
    }

    class Finder {
        double x0 = Double.NEGATIVE_INFINITY;
        double q00 = Double.NaN;
        double q01 = Double.NaN;
        double q10;
        double q11;
        int dnI;
        int upI;
        double square;

        double xt;
        double qt0;
        double qt1;

        Finder find(double targetSquare) {
            for (Pt pt : pts) {
                double x1 = pt.x;
                if (Math.abs(x1 - x0) < EPS)
                    continue;
                while (dnI < dn.size() && dn.get(dnI).x < x1 - EPS)
                    dnI++;
                q10 = getQ(dn, dnI, x1);
                while (upI < up.size() && up.get(upI).x < x1 - EPS || upI + 1 < up.size() && up.get(upI + 1).x <= x1 + EPS)
                    upI++;
                q11 = getQ(up, upI, x1);
                if (x0 > Double.NEGATIVE_INFINITY) {
                    double qh0 = q01 - q00;
                    double qh1 = q11 - q10;
                    double inc = (x1 - x0) * (qh0 + qh1);
                    if (square + inc >= targetSquare) {
                        // targetSquare - square == (x1 - x0) * t * (2*qh0 + t * (qh1 - qh0))
                        double ts = (targetSquare - square) / (x1 - x0);
                        // ts == t * (2*qh0 + t * (qh1 - qh0))
                        // t^2  * (qh1 - qh0) + t * 2*qh0 - ts == 0
                        double a = qh1 - qh0;
                        double t;
                        if (Math.abs(a) < EPS)
                            t = ts / 2 / qh0;
                        else {
                            double b = qh0 / a;
                            double d = Math.sqrt(b * b + ts / a);
                            t = -b + d;
                            if (t > 1 + EPS)
                                t = -b - d;
                        }
                        assert t >= -EPS && t <= 1 + EPS;
                        xt = x0 + t * (x1 - x0);
                        qt0 = q00 + t * (q10 - q00);
                        qt1 = q01 + t * (q11 - q01);
                        return this;
                    }
                    square += inc;
                }
                x0 = x1;
                q00 = q10;
                q01 = q11;
            }
            return this;
        }
    }


    private double getQ(List<Pt> p, int i, double x0) {
        double x2 = p.get(i).x;
        double q2 = p.get(i).q;
        if (Math.abs(x2 - x0) <= EPS)
            return q2;
        double x1 = p.get(i - 1).x;
        double q1 = p.get(i - 1).q;
        return q1 + (q2 - q1) * (x0 - x1) / (x2 - x1);
    }

    void write() throws Exception {
        System.out.println("answer " + answer);
    }

//----------------- just for validation ------------------

    /**
     * Strict scanner to verify 100% correspondence between input files and input file format specification.
     * It is a drop-in replacement for {@link java.util.Scanner} that could be added to a solution source
     * (cut-and-paste) without breaking its ability to work with {@link java.util.Scanner}.
     */
    public class Scanner {
        private final BufferedReader in;
        private String line = "";
        private int pos;
        private int lineNo;

        public Scanner(InputStream in) {
            this.in = new BufferedReader(new InputStreamReader(in));
            nextLine();
        }

        public void close() {
            assert line == null : "Extra data at the end of file";
            try {
                in.close();
            } catch (IOException e) {
                throw new AssertionError("Failed to close with " + e);
            }
        }

        public void nextLine() {
            assert line != null : "EOF";
            assert pos == line.length() : "Extra characters on line " + lineNo;
            try {
                line = in.readLine();
            } catch (IOException e) {
                throw new AssertionError("Failed to read line with " + e);
            }
            pos = 0;
            lineNo++;
        }

        public String next() {
            assert line != null : "EOF";
            assert line.length() > 0 : "Empty line " + lineNo;
            if (pos == 0)
                assert line.charAt(0) > ' ' : "Line " + lineNo + " starts with whitespace";
            else {
                assert pos < line.length() : "Line " + lineNo + " is over";
                assert line.charAt(pos) == ' ' : "Wrong whitespace on line " + lineNo;
                pos++;
                assert pos < line.length() : "Line " + lineNo + " is over";
                assert line.charAt(pos) > ' ' : "Line " + lineNo + " has double whitespace";
            }
            StringBuilder sb = new StringBuilder();
            while (pos < line.length() && line.charAt(pos) > ' ')
                sb.append(line.charAt(pos++));
            return sb.toString();
        }

        public int nextInt() {
            String s = next();
            assert s.length() == 1 || s.charAt(0) != '0' : "Extra leading zero in number " + s + " on line " + lineNo;
            assert s.charAt(0) != '+' : "Extra leading '+' in number " + s + " on line " + lineNo;
            try {
                return Integer.parseInt(s);
            } catch (NumberFormatException e) {
                throw new AssertionError("Malformed number " + s + " on line " + lineNo);
            }
        }
    }
}
