#pragma GCC optimize("O3")
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pi;
#define all(x) begin(x),end(x)
#define rep(i,a,b) for(int i=a;i<b;++i)
#define sz(x) int(x.size())

typedef vector<bitset<350>> 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(all(r), [](auto a, auto b){ return a.d > b.d;});
        int mxD = r[0].d;
        rep(i,0,sz(r)) r[i].d = min(i,mxD) + 1;
    }
    void expand(vv& R, int lev = 1){
        S[lev] += S[lev-1] - old[lev];
        old[lev] = S[lev-1];
        while(sz(R)) {
            if (sz(q) + R.back().d <= sz(qmax)) 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 (sz(T)){
                if (S[lev]++ / ++pk < limit) init(T);
                int j=0, mxk = 1, mnk = max(sz(qmax)-sz(q)+1, 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(all(C[k]), 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;
                rep(k,mnk,mxk+1) for(int i : C[k])
                    T[j].i = i, T[j++].d = k;
                expand(T,lev+1);
            }else if (sz(q) > sz(qmax)) qmax = q;
            q.pop_back(), R.pop_back();
        }
    }
    vi maxClique(){
        init(V), expand(V); return qmax;
    }
    Maxclique(vb conn) : e(conn), C(sz(e)+1), S(sz(C)), old(S) {
        rep(i,0,sz(e)) V.push_back({i});
    }
};
auto dist(array<int,2> a, array<int,2> b) {
    double ans=0;
    for(int i=0;i<2;++i) ans+=(a[i]-b[i])*(a[i]-b[i]);
    return sqrt(ans)+1e-9;
}
int main() {
    cin.tie(NULL);
    cin.sync_with_stdio(false);

    int n; cin >> n;
    double r; cin >> r;

    vector<array<int,2>> sol;

    // edge cases
    bool small = n<=14;
    if (!small and r<=0.5){
        rep(i,1,n) rep(j,1,n) sol.push_back({i,j});
    }else if (!small and r <= sqrt(0.5)){
        for (int i=1; i<n; i+=2) for(int j=1; j<n; j+=2) sol.push_back({i,j});
        for (int i=2; i<n; i+=2) for(int j=2; j<n; j+=2) sol.push_back({i,j});
    }else if (!small and r<=1){
        for (int i=1; i<n; i+=2) for(int j=1; j<n; j+=2) sol.push_back({i,j});
    } else if(!small and r<=sqrt(5./4)) {
        for(int i=2; i<n-1; i+=4) for(int j=2;j<n-1; j+=4) sol.push_back({i,j});
        for(int i=4; i<n-1; i+=4) for(int j=3;j<n-1; j+=4) sol.push_back({i,j});
        for(int i=3; i<n-1; i+=4) for(int j=5;j<n-1; j+=4) sol.push_back({i,j});
        for(int i=6; i<n-1; i+=4) for(int j=4;j<n-1; j+=4) sol.push_back({i,j});
        for(int i=5; i<n-1; i+=4) for(int j=6;j<n-1; j+=4) sol.push_back({i,j});
    } else if(!small and sqrt(2)) {
        for(int i=2;i<=n-2;i+=4) for(int j=2;j<=n-2;j+=4) {
            sol.push_back({i,j});
        }
        for(int i=4;i<=n-2;i+=4) for(int j=4;j<=n-2;j+=4) {
            sol.push_back({i,j});
        }
    } 
    else if (r<=sqrt(13./4)){
        for (int i=2; i<n-1; i+=4) for (int j=2; j<n-1; j+=6) sol.push_back({i,j});
        for (int i=4; i<n-1; i+=4) for (int j=5; j<n-1; j+=6) sol.push_back({i,j});
    }
    else if (r<=2){
           for(int i=2; i<n-1; i+=4) for(int j=2;j<n-1; j+=4) sol.push_back({i,j});
    }
        else{
        
    // // } else{
    // } else {
        int s = int(n+1-r) + int(n+1 - r) - (n+1);
        int shift = llround(ceil(r));
        vb g(s*s);
        auto id = [&](int c, int d) {
            return c*s+d;
        };
        for(int i=0;i<s;++i) for(int j=0;j<s;++j) {
            for(int o=0;o<s;++o) for(int l=0;l<s;++l) if(o!=i or l!=j) {
                if(dist({i,j},{o,l}) >= r*2) {
                    g[id(i,j) ][id(o,l)] = g[id(i,j) ][id(o,l)] = 1;
                }
            }
        }
        // }
        auto mc = Maxclique(g);
        auto res = mc.maxClique();
        cout << res.size() << '\n';
        vector<string> gg(n+1,string(n+1,'.'));
        for(auto idd : res) {
            int i = idd/s;
            int j = idd%s;
            gg[i+shift][j+shift]='*';
            cout << shift+i << ' ' << shift+j << '\n';
        }
        // for(auto s : gg) {
        //     cout << s << '\n';
        // }
        exit(0);
    }
    cout << sol.size() << '\n';
    for(auto [i,j] : sol) cout << i << ' ' << j << '\n';
    

}
/**
1.4
...............
...............
..*...*...*....
...............
....*...*...*..
...............
..*...*...*....
...............
....*...*...*..
...............
..*...*...*....
...............
....*...*...*..
...............
...............


...............
...............
..*.....*...*..
...............
.....*.........
..........*....
..*............
.......*.......
............*..
....*..........
.........*.....
...............
..*...*.....*..
...............
...............

.................
.................
..*.....*.....*..
.................
.....*.....*.....
.................
..*.....*.....*..
.................
.....*.....*.....
.................
..*.....*.....*..
.................
.....*.....*.....
.................
..*.....*.....*..
.................
.................
*/