#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;

struct Vector {
    int x, y, z;
    Vector(void) {}
    Vector(int _x, int _y, int _z): x(_x), y(_y), z(_z) {}
    bool operator < (Vector oth) const {
        if (x != oth.x)
            return x < oth.x;

        if (y != oth.y)
            return y < oth.y;

        if (z != oth.z)
            return z < oth.z;

        return 0;
    }
};
Vector operator + (Vector p, Vector q) {
    return Vector(p.x + q.x, p.y + q.y, p.z + q.z);
}

int n, m, d;

map< tuple<int, int, int>, int > asked;

int ask(int x, int y, int z) {
    if (x < 1 || x > n || y < 1 || y > m || z < 1 || z > d)
        return 0;

    auto cur = make_tuple(x, y, z);

    if (asked.count(cur))
        return asked[cur];

    printf("? %d %d %d\n", x, y, z);
    fflush(stdout);
    int res;
    scanf("%d", &res);

    return asked[cur] = res;
}
void answer(int x, int y, int z) {
    printf("! %d %d %d\n", x, y, z);
    fflush(stdout);
    exit(0);
}

int ask(Vector p) {
    return ask(p.x, p.y, p.z);
}
void answer(Vector p) {
    answer(p.x, p.y, p.z);
}

void solve1(void) {
    int l = 1, r = n;
    int vl = ask(l, 1, 1), vr = ask(r, 1, 1);

    while (r - l + 1 > 5) {
        int mid = (l + r) >> 1;

        int x = ask(mid, 1, 1);

        if (x <= vl) {
            r = mid;
            vr = x;
            continue;
        }

        if (x <= vr) {
            l = mid;
            vl = x;
            continue;
        }

        int y = ask(mid + 1, 1, 1);

        if (x >= y)
            r = mid, vr = x;
        else
            l = mid + 1, vl = y;
    }

    int x = 0, y = vl;

    for (int i = l + 1; i <= r; ++i) {
        int z = i == r ? vr : ask(i, 1, 1);

        if (y >= x && y >= z)
            answer(i - 1, 1, 1);

        x = y;
        y = z;
    }

    answer(r, 1, 1);
}

void solve2(void) {

}

void solve3(int num) {
    mt19937 gen(114514);

    int dx[] = {1, -1, 0, 0, 0, 0};
    int dy[] = {0, 0, 1, -1, 0, 0};
    int dz[] = {0, 0, 0, 0, 1, -1};
    Vector delta[6];

    for (int i = 0; i < 6; ++i)
        delta[i] = Vector(dx[i], dy[i], dz[i]);

    vector< pair<int, Vector>> vec;

    for (int i = 1; i <= num; ++i) {
        int x = uniform_int_distribution<int>(1, n)(gen);
        int y = uniform_int_distribution<int>(1, m)(gen);
        int z = uniform_int_distribution<int>(1, d)(gen);
        vec.emplace_back(ask(x, y, z), Vector(x, y, z));
    }

    sort(vec.begin(), vec.end());
    reverse(vec.begin(), vec.end());

    Vector u = vec[0].second;

    while (1) {
        int my = ask(u);

        int val[6];

        for (int i = 0; i < 6; ++i)
            val[i] = ask(u + delta[i]);

        int pos = max_element(val, val + 6) - val;

        if (val[pos] <= my) {
            answer(u);
        }

        u = u + delta[pos];
    }
}

int main(void) {
    int Q;
    scanf("%d%d%d%d", &n, &m, &d, &Q);
    string t;
    getline(cin, t);

    if (m == 1 && d == 1) {
        solve1();
    }

    if (d == 1) {
        if (Q == 4000)
            solve3(1e3);
        else
            solve3(1.5e3);
    }

    solve3(2e4);
    return 0;
}