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

//using vi = vector<int>;
//typedef vector<bitset<501>> vb;
//
//struct  Maxclique {
//    double limit = 0.025, pk = 0;
//    struct Vertex {int i, d = 0;};
//    typedef vector<Vertex> vv;
//    vb e;
//    vv V;
//    vector<vi> C;
//    vi qmax, q, S, old;
//    void init(vv &r) {
//        for (auto &v : r) v.d = 0;
//        for (auto &v : r) for (auto j : r) v.d += e[v.i][j.i];
//        sort(r.begin(), r.end(), [](auto &&a, auto &&b) {return a.d > b.d;});
//        int mxD = r[0].d;
//        for (int i = 0; i < r.size(); ++i) {
//            r[i].d = min(i, mxD) + 1;
//        }
//    }
//
//    void expand(vv &R, int lev = 1) {
//        if (lev > )
//        S[lev] += S[lev - 1] - old[lev];
//        old[lev] = S[lev - 1];
//
//        while (R.size()) {
//            if (q.size() + R.back().d <= qmax.size()) return;
//            q.push_back(R.back().i);
//            vv T;
//            for (auto v: R)
//                if (e[R.back().i][v.i]) T.push_back({v.i});
//            if (T.size()) {
//                if (S[lev]++ / ++pk < limit) init(T);
//                int j = 0, mxk = 1, mnk = max(qmax.size() - q.size() + 1, (size_t)1);
//                C[1].clear();
//                C[2].clear();
//                for (auto v: T) {
//                    int k = 1;
//                    auto f = [&](int i) {
//                        return e[v.i][i];
//                    };
//
//                    while (any_of(C[k].begin(), C[k].end(), f)) k++;
//                    if (k > mxk) mxk = k, C[mxk + 1].clear();
//                    if (k < mnk) T[j++].i = v.i;
//                    C[k].push_back(v.i);
//                }
//
//                if (j > 0)
//                    T[j - 1].d = 0;
//                for (int k = max(0, mnk); k < mxk + 1; ++k) {
//                    cerr << k << "\n";
//                    for (int i : C[k])
//                        T[j].i = i, T[j++].d = k;
//                }
//                expand(T, lev + 1);
//            } else if (q.size() > qmax.size()) qmax = q;
//            q.pop_back();
//            R.pop_back();
//        }
//    }
//
//    vi maxClique() {
//        init(V);
//        expand(V);
//        return qmax;
//    }
//
//    Maxclique(vb conn) : e(conn), C(e.size() + 1), S(C.size()), old(S) {
//        for (int i = 0; i < e.size(); ++i) {
//            V.push_back({i});
//        }
//    }
//};

using ld = long double;
long double dist(int x, int y, int x2, int y2) {
    return ((ld)x - x2) * ((ld)x - x2) + ((ld)y - y2) * ((ld)y - y2);
}

int main() {
    int n;
    cin >> n;

    long double r, r2;
    cin >> r;
    r2 = 4 * r * r;

    int x = ceil(r);

    vector<pair<int, int>> sol;
    for (int mask = 1; mask < (1 << (n + 1)); ++mask) {
        vector<int> v;
        int pl = mask;
        for (int b = 0; b <= n; ++b) {
            if (mask & (1 << b)) {
                v.push_back(b);
            }
        }

        bool ok = true;
        for (auto it : v) {
            if (it < r || it + r > n) {
                ok = false;
                break;
            }

            for (auto it2 : v) {
                if (it != it2 && dist(0, it, 0, it2) < r2) {
                    ok = false;
                    break;
                }
            }
            if (!ok)
                break;
        }

        if (!ok) {
            continue;
        }
        mask = pl;

        for (int x2 = x + 1; x2 + r <= n; ++x2) {
            vector<int> v2;
            int last = -1;
            for (int y = 0; y <= n; ++y) {
                if (y < r || y + r > n)
                    continue;

                if (last == -1 || dist(x2, y, x2, last) >= r2) {
                    bool ok = true;
                    for (auto it : v) {
                        if (dist(x, it, x2, y) < r2) {
                            ok = false;
                            break;
                        }
                    }

                    if (!ok)
                        continue;
                    last = y;
                    v2.push_back(last);
                }
            }

            if (v2.empty())
                continue;

            vector<pair<int, int>> tmp;
            int tx = x, dx = x2 - x;
            bool ok = true;
            while (tx + r <= n && ok) {
                for (auto it : v) {
                    for (auto it2 : tmp)
                        if (dist(tx, it, it2.first, it2.second) > r2)
                            ok = false;
                    tmp.push_back({tx, it});

                }
                tx += dx;
                if (tx + r > n)
                    break;

                for (auto it : v2) {
                    for (auto it2 : tmp)
                        if (dist(tx, it, it2.first, it2.second) > r2)
                            ok = false;
                    tmp.push_back({tx, it});
                }
                tx += dx;
            }

            if (tmp.size() > sol.size())
                sol = tmp;
        }
    }

    cout << sol.size() << "\n";
    for (auto it : sol)
        cout << it.first << " " << it.second << "\n";
    return 0;
}