/*
 * _|_|_|_|_|  _|_|_|_|    _|_|_|  _|_|_|_|_|  _|_|_|      _|_|
 *       _|    _|        _|                _|        _|  _|    _|
 *     _|      _|_|_|      _|_|          _|      _|_|        _|
 *   _|        _|              _|      _|            _|    _|
 * _|_|_|_|_|  _|        _|_|_|      _|        _|_|_|    _|_|_|_|
 */
 
#include <bits/stdc++.h>
 
std::mt19937 engine(0721);
 
template<class T, class = std::enable_if_t<std::is_integral_v<T>>>
T rand(T l, T r) {
  return std::uniform_int_distribution<T>(l, r)(engine);
}
 
int main() {
#ifdef LOCAL
  freopen("task.in", "r", stdin);
  freopen("task.out", "w", stdout);
  freopen("task.err", "w", stderr);
#endif
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
 
  int N;
  std::cin >> N;
 
#ifdef LOCAL
  std::vector<int> P(N);
  for (auto &v: P) { std::cin >> v; }
  std::iota(P.begin(), P.end(), 1);
  std::ranges::shuffle(P, engine);
  for (auto v: P) { std::cerr << v << ' '; }
  std::cerr << '\n';
#endif
 
  int tot = 0;
  auto Query = [&](int l, int r, int k) {
    if (l + 1 == r) { return 1; }
    tot++;
    std::cout << "? " << l + 1 << ' ' << r << ' ' << k << std::endl;
#ifdef LOCAL
    std::set<int> st;
    for (int i = l; i < r; i++) { st.emplace(P[i] / k); }
    return (int) st.size();
#else
    int x;
    std::cin >> x;
    return x;
#endif
  };
 
  auto Answer = [&](int x) {
    std::cout << "! " << x + 1 << std::endl;
#ifdef LOCAL
    std::cerr << (P[x] == 1 ? "Accepted!\n" : "Wrong Answer!\n");
    std::cerr << "total: " << tot << '\n';
#endif
  };
 
  auto Match = [&](int l, int r) { return r - l - Query(l, r, 2); };
 
  int p1 = -1, p2 = N + 1;
  auto CheckPref = [&](int x) {
    if (x <= p1) { return true; }
    if (p2 <= x) { return false; }
    bool f = 1 < x ? Query(0, x, N) == 1 : Query(x, N, N) != 1;
    if (f) {
      p1 = std::max(p1, x);
    } else {
      p2 = std::min(p2, x);
    }
    return f;
  };
 
  int L = 0, R = N - 1, all = (N + 1) / 2 - 1;
  while (L < R) {
    int M = (L + R + 1) >> 1;
    int ml = Match(0, M), mr = Match(M, N);
    int vl = mr - ml - all + M, vr = ml - mr - all + (N - M);
    std::cerr << M << ' ' << vl << ' ' << vr << '\n';
    if (N & 1) {
      if (vl == 1) {
        R = M - 1;
      } else {
        L = M;
      }
    } else {
      if (vl == 2 || (vl == 1 && CheckPref(M))) {
        R = M - 1;
      } else {
        L = M;
      }
    }
  }
  Answer(L);
 
  return 0;
}