#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void amin(T& x, U y) {
  if (y < x) x = y;
}
template <typename T, typename U>
inline void amax(T& x, U y) {
  if (x < y) x = y;
}
struct P {
  typedef long long T2;
  int x, y;
  P(int x_, int y_) : x(x_), y(y_) {}
  P() : x(0), y(0) {}
};
inline bool operator==(const P& a, const P& b) {
  return a.x == b.x && a.y == b.y;
}
inline bool operator<(const P& a, const P& b) {
  return a.x < b.x || (a.x == b.x && a.y < b.y);
}
inline P operator+(const P& a, const P& b) { return P(a.x + b.x, a.y + b.y); }
inline P operator-(const P& a, const P& b) { return P(a.x - b.x, a.y - b.y); }
inline P operator-=(P& a, const P& b) {
  a.x -= b.x, a.y -= b.y;
  return a;
}
inline P::T2 cross(const P& a, const P& b) {
  return (P::T2)a.x * b.y - (P::T2)a.y * b.x;
}
inline P::T2 dot(const P& a, const P& b) {
  return (P::T2)a.x * b.x + (P::T2)a.y * b.y;
}
inline P::T2 norm(const P& a) { return (P::T2)a.x * a.x + (P::T2)a.y * a.y; }
ostream& operator<<(ostream& out, const P& x) {
  out << "(" << x.x << ", " << x.y << ")";
  return out;
}
inline int ccw(const P& a, const P& b, const P& c) {
  int ax = b.x - a.x, ay = b.y - a.y, bx = c.x - a.x, by = c.y - a.y;
  P::T2 t = (P::T2)ax * by - (P::T2)ay * bx;
  if (t > 0) return 1;
  if (t < 0) return -1;
  if ((P::T2)ax * bx + (P::T2)ay * by < 0) return +2;
  if ((P::T2)ax * ax + (P::T2)ay * ay < (P::T2)bx * bx + (P::T2)by * by)
    return -2;
  return 0;
}
vector<P> convex_hull(vector<P> ps) {
  int n = ps.size(), k = 0;
  sort(ps.begin(), ps.end());
  vector<P> ch(2 * n);
  for (int i = 0; i < n; ch[k++] = ps[i++])
    while (k >= 2 && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0) --k;
  for (int i = n - 2, t = k + 1; i >= 0; ch[k++] = ps[i--])
    while (k >= t && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0) --k;
  ch.resize(k - 1);
  return ch;
}
int n, m;
int ans, sum;
vector<int> ansps, v;
vector<vector<int> > dist;
void solve_rec(int i, int p) {
  if (i == n) {
    if (ans < sum) {
      ans = sum;
      ansps = v;
    }
    return;
  }
  for (int(j) = (int)(p); (j) < (int)(m); ++(j)) {
    int t = 0;
    for (typeof((v).begin()) k = ((v).begin()); k != (v).end(); ++k)
      t += dist[j][*k];
    v.push_back(j);
    sum += t;
    solve_rec(i + 1, j);
    v.pop_back();
    sum -= t;
  }
}
int solve(vector<P> ps) {
  m = ps.size();
  dist.assign(m, vector<int>(m));
  for (int(i) = 0; (i) < (int)(m); ++(i))
    for (int(j) = 0; (j) < (int)(m); ++(j))
      dist[i][j] = (int)norm(ps[i] - ps[j]);
  ans = -1, ansps.clear();
  sum = 0, v.clear();
  solve_rec(0, 0);
  cout << ans << endl;
  for (int(i) = 0; (i) < (int)(n); ++(i))
    cout << ps[ansps[i]].x << " " << ps[ansps[i]].y << endl;
  return ans;
}
int main() {
  int r;
  while (~scanf("%d%d", &n, &r)) {
    vector<P> points;
    for (int(y) = (int)(-r); (y) <= (int)(r); ++(y))
      for (int(x) = (int)(-r); (x) <= (int)(r); ++(x))
        if (y * y + x * x <= r * r) {
          points.push_back(P(x, y));
        }
    vector<P> ch = convex_hull(points);
    solve(ch);
  }
  return 0;
}
