#include <iostream>
#include <vector>
#include <fstream>

using namespace std;

enum Dir {
    UP = 0,
    LEFT = 1,
    DOWN = 2,
    RIGHT = 3
};
const Dir DA[4] = {UP, LEFT, DOWN, RIGHT};
struct Path {
    int value[4];
};
struct Robot {
    int x, y;
    Dir d;
};
typedef vector< vector<Path> > matrix;
int n, s;
matrix a;
Robot r;

void sv(int x, int y, Path p) {
    a.at(x).at(y) = p;
}

void sv(int x, int y, Dir d, int value) {
    a.at(x).at(y).value[d] = value;
}

Path v(int x, int y) {
    return a.at(x).at(y);
}

int v(int x, int y, Dir d) {
    return v(x, y).value[d];
}

int v(const Robot& r) {
    return v(r.x, r.y, r.d);
}

pair<int, int> go(const Robot& r, int go) {
    int x = r.x;
    int y = r.y;
    switch (r.d) {
        case UP:
            y-=go;
            break;
        case LEFT:
            x-=go;
            break;
        case DOWN:
            y+=go;
            break;
        case RIGHT:
            x+=go;
            break;
    }
    return make_pair(x, y);
}

bool isBlock(int x, int y) {
    return v(x, y, UP) == -1;
}

bool nextOut(const Robot& r) {
    switch (r.d) {
        case UP: return r.y == 0;
        case LEFT: return r.x == 0;
        case DOWN: return r.y == n;
        case RIGHT: return r.x == n;
    }
}

void display(Dir d) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cout << v(i, j, d) << " ";
        }
        cout << endl;
    }
}

//cột x dòng y
int main()
{
    ifstream in;
    in.open("robot.inp");
    in >> n >> r.x >> r.y >> s;
    r.d = UP;

    a.resize(n, vector<Path> (n, {0, 0, 0, 0}));
    for (int j = 0; j < n; j++) {
        for (int i = 0; i < n; i++) {
            char c;
            in >> c;
            //cout << c << " ";
            if (c == '#') {
                sv(i, j, {-1, -1, -1, -1});
            } else {
                int up = (j == 0) ? 0 : v(i, j - 1, UP) + 1;
                int left = (i == 0) ? 0 : v(i - 1, j, LEFT) + 1;
                if (i > 0) {
                    int right = v(i - 1, j, RIGHT);
                    if (right > -1) sv(i - 1, j, RIGHT, right + 1);
                }
                if (j > 0) {
                    int down = v(i, j - 1, DOWN);
                    if (down > -1) sv(i, j - 1, DOWN, down + 1);
                }

                //down = (j == 0) ? 0 : v(i, j - 1).value[1] + 1;
                //right = (i == n - 1) ? 0 : v(i - 1, j).value[2] + 1;
                //down = (j == n - 1) ? 0 : v(i, j - 1).down + 1;
                sv(i, j, {up, left, 0, 0});
            }
        }
        cout << endl;
    }

    in.close();

    /*cout << "UP" << endl;
    display(UP);
    cout << "LEFT" << endl;
    display(LEFT);
    cout << "DOWN" << endl;
    display(DOWN);
    cout << "RIGHT" << endl;
    display(RIGHT);*/

    n--;
    r.x--;
    r.y--;
    if (r.x < 0 || r.x > n || r.y < 0) {
        r.y+=s;
        s=0;
    } else if (r.y > n) {
        bool stop = v(r.x, n, UP) == -1;
        int range = r.y - n - stop;
        int go = min(range, s);
        r.y-=go;
        s-=go;
        if (s > 0 && stop) {
            r.x-=s;
            s=0;
            r.d = DA[(r.d + 1)%4];
        }
    }
    while (s > 0) {
        if (nextOut(r)) {
            pair<int, int> go_res = go(r, s);
            r.x = go_res.first;
            r.y = go_res.second;
            break;
        }
        bool block = true;
        while (block) {
            pair<int, int> next_to = go(r, 1);
            block = isBlock(next_to.first, next_to.second);
            if (block) r.d = DA[(r.d + 1) % 4];
        }
        int go_range = min(v(r.x, r.y, r.d), s);
        pair<int, int> go_res = go(r, go_range);
        r.x = go_res.first;
        r.y = go_res.second;
        s-=go_range;
    }

    ofstream out;
    out.open("robot.out");
    out << r.x + 1 << " " << r.y + 1;
    //cout << r.x + 1 << " " << r.y + 1;
    out.close();


    return 0;
}