#include <map>
#include <cmath>
#include <ctime>
#include <cstdio>
#include <random>
#include <algorithm>
std::mt19937 rnd(time(NULL));
int n, m, k;
struct Node {
    int x, y, z;
    Node(int _x = 0, int _y = 0, int _z = 0) {
        x = _x, y = _y, z = _z;
    }
    friend Node operator +(const Node &a, const Node &b) {
        return Node(a.x + b.x, a.y + b.y, a.z + b.z);
    }
    friend Node operator *(const Node &a, int b) {
        return Node(a.x * b, a.y * b, a.z * b);
    }
    friend bool operator <(const Node &a, const Node &b) {
        return a.x == b.x ? (a.y == b.y ? a.z < b.z : a.y < b.y) : a.x < b.x;
    }
};
const Node d[6] = {Node(1, 0, 0), Node(-1, 0, 0), Node(0, 1, 0), Node(0, -1, 0), Node(0, 0, 1), Node(0, 0, -1)};
std::map<Node, int> mp;
int query(Node a) {
    if (a.x < 1 || a.x > n || a.y < 1 || a.y > m || a.z < 1 || a.z > k) {
        return 0;
    }

    if (mp.count(a) > 0)
        return mp[a];

    printf("? %d %d %d\n", a.x, a.y, a.z);
    fflush(stdout);
    scanf("%d", &mp[a]);
    return mp[a];
}
Node solve(Node a) {
    double x = (3 - sqrt(5)) / 2;
    int val = query(a);

    for (int i = 0; i < 6; ++i) {
        int tmp = query(a + d[i]);

        if (tmp <= val)
            continue;

        int left = 1, right;

        switch (i) {
        case 0:
            right = n - a.x;
            break;

        case 1:
            right = a.x;
            break;

        case 2:
            right = m - a.y;
            break;

        case 3:
            right = a.y;
            break;

        case 4:
            right = k - a.z;
            break;

        default:
            right = a.z;
        }

        int l = left + floor((right - left) * x), r = right - floor((right - left) * x);

        while (l < r) {
            int u = query(a + d[i] * l), v = query(a + d[i] * r);

            if (u <= v && val <= v)
                left = l + 1, l = r, r = right - floor((right - left) * x);
            else
                right = r - 1, r = l, l = left + floor((right - left) * x);
        }

        while (left < right) {
            int mid = (left + right) / 2;
            int u = query(a + d[i] * mid), v = query(a + d[i] * (mid + 1));

            if (u <= v && val <= v)
                left = mid + 1;
            else
                right = mid;
        }

        return solve(a + d[i] * left);
    }

    return a;
}
int main() {
    scanf("%d%d%d%*d", &n, &m, &k);
    Node ans;
    ans.x = rnd() % n + 1, ans.y = rnd() % m + 1, ans.z = rnd() % k + 1;
    ans = solve(ans);
    printf("! %d %d %d", ans.x, ans.y, ans.z);
}