#include <bits/stdc++.h>
using namespace std;

using ll = long long;
#define int ll
#define all(v) (v).begin(), (v).end()
#define pb push_back

void dbg_out() { cerr << endl; }
template <typename H, typename... T>
void dbg_out(H h, T... t) { cerr << ' ' << h; dbg_out(t...); }
#define dbg(...) { cerr << #__VA_ARGS__ << ':'; dbg_out(__VA_ARGS__); }

const int INF = 1e12;

struct Dinic {
    struct edge {
        int to, cap, flow;
    };

    vector<vector<int>> g;
    vector<int> lvl;
    vector<edge> e;

    Dinic (int sz) : g (sz), lvl (sz) {}

    void add_edge (int s, int t, int cap) {
        int id = e.size ();
        g[s].push_back(id);
        e.push_back ({t, cap, 0});
        g[t].push_back (++id);
        e.push_back ({s, cap, cap});
    }

    bool bfs (int s, int t) {
        fill (all (lvl), INF);
        lvl[s] = 0;
        queue<int> q;
        q.push (s);
        while (!q.empty () && lvl[t] == INF) {
            int v = q.front ();
            q.pop ();
            for (int id : g[v]) {
                auto [p, cap, flow] = e[id];
                if (lvl[p] != INF || cap == flow) continue;
                lvl[p] = lvl[v] + 1;
                q.push (p);
            }
        }
        return lvl[t] != INF;
    }

    int dfs (int v, int pool, int t, vector<int>  &st) {
        if (!pool) return 0;
        if (v == t) return pool;
        for (; st[v] < (int) g[v].size (); st[v]++) {
            int id = g[v][st[v]];
            auto &[p, cap, flow] = e[id];
            if (lvl[v] + 1 != lvl[p] || cap == flow) continue;
            int f = dfs (p, min (cap - flow, pool), t, st);
            if (f) {
                flow += f;
                e[id ^ 1].flow -= f;
                return f;
            }
        }
        return 0;
    }

    int get_flow (int s, int t) {
        int res = 0;
        vector<int> start (g.size ());
        while (bfs (s, t)) {
            fill (all (start), 0);
            while (int f = dfs (s, INF, t, start))
                res += f;
        }
        return res;
    }
};


void dfs (int n, int m, vector<pair<int, int>> &ans) {
    assert (!(n <= 0 || m <= 0));
    // dbg (n, m, ans.size ());
    if (m == 2 * n && (n & 1)) {
        for (int j = 1; j <= n; j++) ans.pb ({j, 1});
        for (int j = 1; j <= n; j++) ans.pb ({j, m});
        for (int x = 2; x <= n; x += 2) ans.pb ({x, n}), ans.pb ({x, n + 1});
        return;
    }
    if (n == 2 * m && (m & 1)) {
        for (int j = 1; j <= m; j++) ans.pb ({1, j});
        for (int j = 1; j <= m; j++) ans.pb ({n, j});
        for (int x = 2; x <= m; x += 2) ans.pb ({m, x}), ans.pb ({m + 1, x});
        return;
    }
    if (n < m) {
        for (int i = 1; i <= n; i++) ans.pb ({i, m});
        dfs (n, m - n, ans);
    }
    else if (m < n) {
        for (int j = 1; j <= m; j++) ans.pb  ({n, j});
        dfs (n - m, m, ans);
    }
    else {
        assert (n == m);
        for (int i = 1; i < n; i++) ans.pb ({i, m}), ans.pb ({i, 1});
        if (n == 1) ans.pb ({1, 1});
    }
}

int brute (int n, int m) {
    int s = 5 * n + 5 * m, t = s + 1;

    Dinic grafo (5 * n + 5 * m + 2);

    vector<vector<int>> diag (2);
    for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) {
        diag[0].pb (i - j);
        diag[1].pb (i + j);
    }

    sort (all (diag[0]));
    diag[0].resize (unique (all (diag[0])) - diag[0].begin ());


    sort (all (diag[1]));
    diag[1].resize (unique (all (diag[1])) - diag[1].begin ());

    const int shift = n + m;
    int p = 0;
    map<int, int> M;
    for (auto u : diag[0]) {
        grafo.add_edge (s, p, 1);
        M[u] = p++;
    }
    for (auto u : diag[1]) {
        grafo.add_edge (p, t, 1);
        M[u + shift] = p++;
    }

    for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) {
        grafo.add_edge (M[i - j], M[i + j + shift], 1);
    }
    return grafo.get_flow (s, t);
}

void solve (int n, int m) {
    // cin >> n >> m;
    vector<pair<int, int>> ans;
    dfs (n, m, ans);

    // {
    //     vector<int> diag (2 * (n + m));
    //     for (auto [x, y] : ans) {
    //         assert (diag[n + m + x - y] == 0);
    //         diag[n + m + x - y]++;
    //     }
    // }
    // {
    //     vector<int> diag (2 * (n + m));
    //     for (auto [x, y] : ans) {
    //         assert (diag[x + y] == 0);
    //         diag[x + y]++;
    //     }
    // }
    // assert (n + m - 2 <= ans.size ());
    // int matching = brute (n, m);
    // dbg (n, m, ans.size (), matching);
    // assert (ans.size () == matching);
    cout << ans.size () << "\n";
    for (auto [x, y] : ans)
        cout << x << " " << y << "\n";
}

signed main() {
	ios::sync_with_stdio(false); cin.tie(0);
    int n, m; cin >> n >> m;
    solve (n, m);
    // for (int i = 1; i <= 100; i++) {
    //     for (int j = i; j <= 100; j++) {
	//         solve(i, j);
    //     }
    // }
}