#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <stack>
#include <cassert>
#include <map>
#include <numeric>
#include <cstring>
#include <set>
#include <ctime>
#include <queue>
#include <cmath>
#include <iomanip>
#include <iterator>
#include <bitset>
#include <unordered_map>
#include <complex>
#include <unordered_set>
#include <chrono>
#include <random>
#include <array>
#include <functional>
#include <random>

using namespace std;

int R, C;
int bestDist, ansP, ansI, ansJ, ansC;

bool check(int p, int i, int j, int steps) {
    long long target = 1LL * (i - 1) * C + j - 1;
    p --;
    for (int pos = 0; pos < R * C; pos ++) {
        long long aux = pos, cntSteps = steps;
        while (cntSteps --)
            aux = 1LL * p * R + aux / C;
        if (aux != target)
            return 0;
    }
    return 1;
}

int mod(int x) {
    if (x < 0) return -x;
    return x;
}

int minDist(int i, int R) {
    if (R % 2 == 1) return mod(i - (R + 1) / 2);
    return min(mod(i - R / 2), mod(i - (R / 2 + 1)));
}

void consider(int p, int i, int j, int steps) {
    int dist = minDist(i + 1, R) + minDist(j + 1, C);
    //int dist = (i <= (R - 1) / 2 ? (R - 1) / 2 - i : i - (R / 2)) + (j <= (C - 1) / 2 ? (C - 1) / 2 - j : j - (C / 2));
    if (dist < bestDist || (dist == bestDist && p < ansP)) {
        bestDist = dist;
        ansI = i;
        ansJ = j;
        ansP = p;
        ansC = steps;
    }
}

void tryP(int p) {
    long long beta = 1LL * p * R;
    long long l = 0, r = 1LL * R * C - 1;
    int steps = 0;
    //printf("%d: [%lld, %lld]\n", p, l, r);
    while (l < r) {
        long long newL = beta + l / C, newR = beta + r / C;
        if (newL == l && newR == r)
            return ;
        if (newL < l || newR > r)
            return ;
        l = newL, r = newR;
        steps ++;
        //printf("[%lld, %lld]\n", l, r);
    }
    consider(p, l / C, l % C, steps);
}

int main() {
    //freopen("../input", "r", stdin);
    //freopen("../output", "w", stdout);

    scanf ("%d %d", &R, &C);
    bestDist = 4 * R + 4 * C + 1, ansP = -1, ansI = -1, ansJ = -1, ansC = -1;
    for (int p=0; p + 1<C; p++)
        tryP(p);
    /*for (int p=0; p + 1<C; p++) {
        int beta = p * R;
        for (int i = 0; i < R; i++)
            for (int j = 0; j < C; j++) {
                int l = i * C + j, r = l;
                if (beta > l || beta + R <= l)
                    continue;
                int steps = 0;
                bool ok = 1;
                if (i == 3 && j == 1 && p == 1)
                    printf("[%d, %d]\n", l, r);
                while (l > 0 || r < R * C - 1) {
                    steps++;
                    int newL = max(l - beta, 0) * C;
                    int newR = min(R * C - 1, r * C + (C - 1) - beta);
                    if (newL > l || newR < r || (newL == l && l != 0) || (newR == r && r + 1 != R * C)) {
                        ok = 0;
                        break;
                    }
                    l = newL, r = newR;
                    if (i == 3 && j == 1 && p == 1)
                        printf("[%d, %d]\n", newL, newR);
                }
                if (ok && steps) {
                    consider(p, i, j, steps);
                }
            }
    }*/
    printf("%d %d %d %d\n", ansP + 1, ansI + 1, ansJ + 1, ansC);
    //assert(check(ansP + 1, ansI + 1, ansJ + 1, ansC));
    return 0;
}

/*const int seed = time (0);
mt19937 gen (seed);
long long getRand(long long a, long long b) {return uniform_int_distribution < long long > (a, b) (gen);}*/