#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <set>
#include <map>
#include <vector>
#include <string>

#include <cmath>
#include <queue>
#include <stack>

#include <unordered_set>
#include <unordered_map>
#include <array>

using namespace std;

#define LL long long

#include <cassert>
#include <vector>

inline int read() {
    int x = 0, f = 1;
    char c = getchar();
    while (c < '0' || c > '9') {
        if (c == '-') {
            f = -1;
        }
        c = getchar();
    }
    while (c >= '0' && c <= '9') {
        x = x * 10 + c - '0';
        c = getchar();
    }
    return x * f;
}

inline void write(int x) {
    static int sta[35];
    int top = 0;
    do {
        sta[top++] = x % 10, x /= 10;
    } while (x);
    while (top) putchar(sta[--top] + 48); 
}

inline void writeln(int x) {
	if (x < 0) {
		putchar('-'); x = -x;
	}
    static int sta[35];
    int top = 0;
    do {
        sta[top++] = x % 10, x /= 10;
    } while (x);
    while (top) putchar(sta[--top] + 48); 
	putchar('\n');
}

inline LL readll() {
    LL x = 0, f = 1;
    char c = getchar();
    while (c < '0' || c > '9') {
        if (c == '-') {
            f = -1;
        }
        c = getchar();
    }
    while (c >= '0' && c <= '9') {
        x = x * 10 + c - '0';
        c = getchar();
    }
    return x * f;
}

inline void writell(LL x) {
	if (x < 0) {
		putchar('-'); x = -x;
	}
    static LL sta[35];
    int top = 0;
    do {
        sta[top++] = x % 10, x /= 10;
    } while (x);
    while (top) putchar(sta[--top] + 48); 
}

inline void writellln(LL x) {
	if (x < 0) {
		putchar('-'); x = -x;
	}
    static LL sta[35];
    int top = 0;
    do {
        sta[top++] = x % 10, x /= 10;
    } while (x);
    while (top) putchar(sta[--top] + 48); 
	putchar('\n');
}

const int hashMod = 999983;

template<class TYPENAME>
class HashNode {
public:
    TYPENAME val;
    int key, next;
    HashNode(TYPENAME _val, int _key, int _next): val(_val), key(_key), next(_next) {}
    bool isNull() {
        return key == -1;
    }
};

template<class TYPENAME>
class Hash {
public:
    vector<HashNode<TYPENAME> > nodes;
    vector<int> d;
    int nodeN;
    Hash() {
        nodeN = 0; 
        d = vector<int>(hashMod, -1);
    }
    void push(int key, TYPENAME val) {
        nodes.push_back(HashNode<TYPENAME>(val, key, d[key]));
        d[key] = nodeN++;
    }
    HashNode<TYPENAME> find(int key, TYPENAME val) {
        for (int p = d[key]; p != -1; p = nodes[p].next) {
            if (nodes[p].val == val) {
                return nodes[p];
            }
        }
        return HashNode<TYPENAME>(val, -1, -1);
    }
};

vector<int> a, b;
int n, k, p, s;

int currQ = 0;

void query(int q) {
    cout << "? " << ((q % n) + 1) << endl;
    currQ = q;
    cout.flush();
}

int getAns() {
    int res = 0;
    cin >> res;
    return res;
}

int virtualAns() {
    for (int i = 0; i < 1; ++i) {
        for (int j = 0; j < n; ++j) {
            b[j] = 0;
        }
        for (int j = 0; j < n; ++j) {
            if (j != p) {
                b[(j - 1 + n) % n] += (a[j] / 2);
                b[(j + 1) % n] += ((a[j] + 1) / 2);
            } else {
                b[(j + 1) % n] += a[j];
            }
        }
        swap(a, b);
        // for (int i = 0; i < n; ++i) {
        //     cout << a[i] << ' ';
        // }
        // cout << endl;
    }
    cout << "= " << a[currQ] << endl;
    return a[currQ];
}

void giveAns(int r) {
    cout << "! " << (r % n + 1) << endl;
}

// #define LOCAL_DEBUG

void searchImposter(int l, int r) {
    // note that there can be the case where r < l, we need to set some offset
    int offset = l;
    l -= offset; r = (r - offset + n) % n;
    // then [l, r] can be queried
    // for a given query q, we need to take q + offset
    while (l < r) {
        // printf("l = %d, r = %d\n", l, r);
        int mid = (l + r) / 2;
        query((mid + offset) % n);
        int res;
        #ifdef LOCAL_DEBUG
            res = virtualAns();
        #else 
            res = getAns();
        #endif
        if (res == k) {
            giveAns(mid + offset); return ;
        }
        if (res < k) {
            // left 
            l = mid + 1;
        } else {
            r = mid;
        }
    }
    giveAns(l + offset);
}

int spreadN;
int lastAns = -1, nowAns;
int main() {
	// std::ios::sync_with_stdio(false);
    // std::cin.tie(0);
    n = read(); k = read();
    spreadN = int(sqrt(n + 1));

    #ifdef LOCAL_DEBUG
        p = read() - 1;
    #endif

    a = vector<int>(n, k);
    b = vector<int>(n);
    for (int i = 0; i < spreadN; ++i) {
        query(0); 
        #ifdef LOCAL_DEBUG
            virtualAns();
        #else
            getAns(); 
        #endif
    }
    for (int i = 0; i < n + spreadN; i += spreadN) {
        query(i % n);
        #ifdef LOCAL_DEBUG
            nowAns = virtualAns();
        #else
            nowAns = getAns();
        #endif
        if (lastAns != -1 && lastAns < k && nowAns >= k) {
            searchImposter(((i - spreadN) + n) % n, i);
            return 0;
        } else {
            lastAns = nowAns;
        }
    }
    lastAns = -1;
    for (int i = 0; i < n + spreadN; i += 1) {
        query(i % n);
        #ifdef LOCAL_DEBUG
            nowAns = virtualAns();
        #else
            nowAns = getAns();
        #endif
        if (lastAns != -1 && lastAns < k && nowAns == k) {
            giveAns(i);
            return 0;
        } else {
            lastAns = nowAns;
        }
    }

    // searchImposter(p, p + 3);
	return 0;
}