#include <cmath>
#include <iostream>
#include <vector>
#include <algorithm>

struct Vector3 {
int x;
int y;
int z;

bool operator !=(const Vector3& other) {
return (x != other.x) && (y != other.y) && (z != other.z);
}
};

struct Cell {
int value;
Vector3 pos;
};

using Tensor = std::vector<std::vector<std::vector<Cell>>>;
using SparseTable = std::vector<std::vector<std::vector<Tensor>>>;
using SparseTable2d = std::vector<std::vector<Tensor>>;
using Matrix = std::vector<std::vector<Cell>>;

Cell maxCell(const Cell& a, const Cell& b) {
return (a.value >= b.value) ? a : b;
}

struct QueryResult {
int value;
Vector3 pos;
};

QueryResult query_max(const SparseTable& table, Vector3 start, Vector3 size) {
int x = start.x;
int y = start.y;
int z = start.z;

int a = size.x;
int b = size.y;
int c = size.z;

int x2 = x + a - 1;
int y2 = y + b - 1;
int z2 = z + c - 1;

int logx = std::log2(a);
int logy = std::log2(b);
int logz = std::log2(c);

int x_shift = (1 << logx);
int y_shift = (1 << logy);
int z_shift = (1 << logz);

std::vector<Cell> cells = {
table[x][y][z][logx][logy][logz],
table[x2 - x_shift + 1][y][z][logx][logy][logz],
table[x][y2 - y_shift + 1][z][logx][logy][logz],
table[x][y][z2 - z_shift + 1][logx][logy][logz],
table[x2 - x_shift + 1][y2 - y_shift + 1][z][logx][logy][logz],
table[x2 - x_shift + 1][y][z2 - z_shift + 1][logx][logy][logz],
table[x][y2 - y_shift + 1][z2 - z_shift + 1][logx][logy][logz],
table[x2 - x_shift + 1][y2 - y_shift + 1][z2 - z_shift + 1][logx][logy][logz]
};

Cell best = cells[0];
for (auto& c : cells)
if (c.value > best.value)
best = c;

return {best.value, best.pos};
}

int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);

int n, m, k;
std::cin >> n >> m >> k;

int a, b, c;
std::cin >> a >> b >> c;

Tensor field(n, Matrix(m, std::vector<Cell>(k)));
SparseTable table(n, SparseTable2d(m, std::vector<Tensor>(k, field)));

for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
for (int o = 0; o < k; ++o) {
int val;
std::cin >> val;
field[i][j][o] = {val, {i, j, o}};
table[i][j][o][0][0][0] = {val, {i, j, o}};
}
}
}

int log_n = std::log2(n);
int log_m = std::log2(m);
int log_k = std::log2(k);

for (int px = 1; px <= log_n; ++px)
for (int i = 0; i + (1 << px) - 1 < n; ++i)
for (int j = 0; j < m; ++j)
for (int o = 0; o < k; ++o)
table[i][j][o][px][0][0] =
maxCell(table[i][j][o][px - 1][0][0],
table[i + (1 << (px - 1))][j][o][px - 1][0][0]);

for (int py = 1; py <= log_m; ++py)
for (int i = 0; i < n; ++i)
for (int j = 0; j + (1 << py) - 1 < m; ++j)
for (int o = 0; o < k; ++o)
table[i][j][o][0][py][0] =
maxCell(table[i][j][o][0][py - 1][0],
table[i][j + (1 << (py - 1))][o][0][py - 1][0]);

for (int pz = 1; pz <= log_k; ++pz)
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
for (int o = 0; o + (1 << pz) - 1 < k; ++o)
table[i][j][o][0][0][pz] =
maxCell(table[i][j][o][0][0][pz - 1],
table[i][j][o + (1 << (pz - 1))][0][0][pz - 1]);

for (int px = 1; px <= log_n; ++px)
for (int py = 1; py <= log_m; ++py)
for (int i = 0; i + (1 << px) - 1 < n; ++i)
for (int j = 0; j + (1 << py) - 1 < m; ++j)
for (int o = 0; o < k; ++o) {
Cell v1 = table[i][j][o][px - 1][py - 1][0];
Cell v2 = table[i + (1 << (px - 1))][j][o][px - 1][py - 1][0];
Cell v3 = table[i][j + (1 << (py - 1))][o][px - 1][py - 1][0];
Cell v4 = table[i + (1 << (px - 1))][j + (1 << (py - 1))][o][px - 1][py - 1][0];
table[i][j][o][px][py][0] = maxCell(maxCell(v1, v2), maxCell(v3, v4));
}

for (int px = 1; px <= log_n; ++px)
for (int pz = 1; pz <= log_k; ++pz)
for (int i = 0; i + (1 << px) - 1 < n; ++i)
for (int j = 0; j < m; ++j)
for (int o = 0; o + (1 << pz) - 1 < k; ++o) {
Cell v1 = table[i][j][o][px - 1][0][pz - 1];
Cell v2 = table[i + (1 << (px - 1))][j][o][px - 1][0][pz - 1];
Cell v3 = table[i][j][o + (1 << (pz - 1))][px - 1][0][pz - 1];
Cell v4 = table[i + (1 << (px - 1))][j][o + (1 << (pz - 1))][px - 1][0][pz - 1];
table[i][j][o][px][0][pz] = maxCell(maxCell(v1, v2), maxCell(v3, v4));
}

for (int py = 1; py <= log_m; ++py)
for (int pz = 1; pz <= log_k; ++pz)
for (int i = 0; i < n; ++i)
for (int j = 0; j + (1 << py) - 1 < m; ++j)
for (int o = 0; o + (1 << pz) - 1 < k; ++o) {
Cell v1 = table[i][j][o][0][py - 1][pz - 1];
Cell v2 = table[i][j + (1 << (py - 1))][o][0][py - 1][pz - 1];
Cell v3 = table[i][j][o + (1 << (pz - 1))][0][py - 1][pz - 1];
Cell v4 = table[i][j + (1 << (py - 1))][o + (1 << (pz - 1))][0][py - 1][pz - 1];
table[i][j][o][0][py][pz] = maxCell(maxCell(v1, v2), maxCell(v3, v4));
}

for (int px = 1; px <= log_n; ++px)
for (int py = 1; py <= log_m; ++py)
for (int pz = 1; pz <= log_k; ++pz)
for (int i = 0; i + (1 << px) - 1 < n; ++i)
for (int j = 0; j + (1 << py) - 1 < m; ++j)
for (int o = 0; o + (1 << pz) - 1 < k; ++o) {
int x1 = i, y1 = j, z1 = o;
int x2 = i + (1 << (px - 1));
int y2 = j + (1 << (py - 1));
int z2 = o + (1 << (pz - 1));

Cell v1 = table[x1][y1][z1][px - 1][py - 1][pz - 1];
Cell v2 = table[x2][y1][z1][px - 1][py - 1][pz - 1];
Cell v3 = table[x1][y2][z1][px - 1][py - 1][pz - 1];
Cell v4 = table[x2][y2][z1][px - 1][py - 1][pz - 1];
Cell v5 = table[x1][y1][z2][px - 1][py - 1][pz - 1];
Cell v6 = table[x2][y1][z2][px - 1][py - 1][pz - 1];
Cell v7 = table[x1][y2][z2][px - 1][py - 1][pz - 1];
Cell v8 = table[x2][y2][z2][px - 1][py - 1][pz - 1];

table[i][j][o][px][py][pz] =
maxCell(maxCell(maxCell(v1, v2), maxCell(v3, v4)),
maxCell(maxCell(v5, v6), maxCell(v7, v8)));
}

int q;

std::cin >> q;

Vector3 size = {a, b, c};

while (q-- > 0) {
int x;
int y;
int z;

std::cin >> x >> y >> z;
Vector3 start = {x, y, z};

QueryResult res = query_max(table, start, size);

while (res.pos != start) {
start = res.pos;

res = query_max(table, start, size);
}
std::cout << res.pos.x << " " << res.pos.y << " " << res.pos.z << "\n";
}
}

/*
39 94 94 63
27 79 10 69
28 86 61 79
97 78 64 23

94 94 94
86 86 79
97 86 79
*/