#include <bits/stdc++.h>
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) FOR(i,0,n)
#define repr(i,n) for(int i=(n)-1;0<=i;--i)
#define each(e,v) for(auto&& e:(v))
#define all(v) begin(v),end(v)
#define dump(x) cerr<<#x<<": "<<(x)<<endl
using namespace std;
using vint = vector<int>;
using ll = long long;
using vll = vector<ll>;
template <class T> void chmin(T& a, const T& b) { a = min(a, b); }
template <class T> void chmax(T& a, const T& b) { a = max(a, b); }

namespace Timer {
    using namespace std::chrono;
    high_resolution_clock::time_point start_time;
    inline void init() {
        start_time = high_resolution_clock::now();
    }
    inline int now() {
        auto now = high_resolution_clock::now();
        auto t = now - start_time;
        return duration_cast<milliseconds>(t).count();
    }
    inline bool check(int limit) {
        return now() < limit;
    }
}

struct Data {
    bool isH;
    int x, y;
};

void output(int l, Data d) {
    int eX = d.isH ? d.x : (d.x + l - 1);
    int eY = d.isH ? (d.y + l - 1) : d.y;
    cout << d.y+1 << " " << d.x+1 << " " << eY+1 << " " << eX+1 << endl;
}

vector<vint> imosX2grid(vector<vint> imos) {
    const int n = imos.size();
    rep(y, n) rep(x, n-1) {
        imos[y][x+1] += imos[y][x];
    }
    return imos;
}

int calcScore(const vector<vint>& grid) {
    const int n = grid.size();
    int cnt = 0;
    rep(y, n) rep(x, n) if(grid[y][x] % 2 == 0) cnt++;
    return cnt;
}

int main() {
    Timer::init();
    int n, k; cin >> n >> k;
    vint L(k);
    rep(i, k) cin >> L[i];
    vector<vint> A(n, vint(n));
    rep(y, n) rep(x, n) { char c; cin >> c; A[y][x] = c == '1'; }

    cerr << "imos" << endl;
    vector<vint> imosX(n, vint(n, 0));
    rep(y, n) {
        rep(x, n) imosX[y][x] = A[y][x];
        rep(x, n-1) imosX[y][x+1] -= A[y][x];
    }

    cerr << "random" << endl;
    mt19937 mt(random_device{}());
    vector<Data> data(k);
    rep(i, k) {
        data[i].isH = false;
        data[i].x = uniform_int_distribution<>(0, n - L[i])(mt);
        data[i].y = uniform_int_distribution<>(0, n-1)(mt);
        imosX[data[i].y][data[i].x]++;
        imosX[data[i].y][data[i].x + L[i]]--;
    }

    int initialScore = calcScore(A);
    int cycle = 0, cntAccept = 0;

    vector<Data> bestData = data;
    int bestScore = calcScore(imosX2grid(imosX));
    constexpr double paramA = 1;
    constexpr double paramB = 4;
    constexpr double initTemp = 100;

    while(Timer::check(900)) {
        cycle++;
        // const double progress = (cycle + 0.5) / Num;
        const double progress = Timer::now() / 900.0;
        const double T = initTemp * pow(1 - progress, paramA) * exp2(-progress * paramB);

        // nextStep
        int beforeScore = calcScore(imosX2grid(imosX));
        // int rk = uniform_int_distribution<>(0, k-1)(mt);
        int rk = cycle % k;
        int rx = uniform_int_distribution<>(0, n - L[rk])(mt);
        int ry = uniform_int_distribution<>(0, n-1)(mt);

        imosX[data[rk].y][data[rk].x]--;
        imosX[data[rk].y][data[rk].x + L[rk]]++;
        imosX[ry][rx]++;
        imosX[ry][rx + L[rk]]--;

        int newScore = calcScore(imosX2grid(imosX));
        if(beforeScore < newScore) { // || uniform_real_distribution<>(0, 1)(mt) <= exp(newScore - beforeScore) / T) {
            data[rk].x = rx;
            data[rk].y = ry;
            cntAccept++;

            if(bestScore < newScore) {
                bestScore = newScore;
                bestData = data;
            }
        } else {
            imosX[ry][rx]--;
            imosX[ry][rx + L[rk]]++;
            imosX[data[rk].y][data[rk].x]++;
            imosX[data[rk].y][data[rk].x + L[rk]]--;
        }
    }

    cerr << "output" << endl;
    rep(i, k) output(L[i], bestData[i]);

    dump(cycle);
    dump(cntAccept);
    cerr << "score: " << (bestScore - initialScore) << endl;

    return 0;
}