#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
const int INF = 1 << 29;
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
  int res = 0;
  while (n && ++res) n -= n & (-n);
  return res;
}
template <class T>
void chmax(T& a, const T& b) {
  a = max(a, b);
}
template <class T>
void chmin(T& a, const T& b) {
  a = min(a, b);
}
class MersenneTwister {
 private:
  enum { MT_N = 624, MT_M = 397, MT_MSB = 0x80000000U, MT_LS31B = 0x7FFFFFFFU };
  unsigned int MT[MT_N];
  int index;
  void generate() {
    unsigned int temp;
    int i = 0;
    for (; i < MT_N - MT_M; ++i) {
      temp = (MT[i] & MT_MSB) + (MT[i + 1] & MT_LS31B);
      MT[i] = MT[i + MT_M] ^ (temp >> 1) ^ (2567483615U & -(temp & 1));
    }
    for (; i < MT_N - 1; ++i) {
      temp = (MT[i] & MT_MSB) + (MT[i + 1] & MT_LS31B);
      MT[i] = MT[i + MT_M - MT_N] ^ (temp >> 1) ^ (2567483615U & -(temp & 1));
    }
    temp = (MT[i] & MT_MSB) + (MT[0] & MT_LS31B);
    MT[i] = MT[MT_M - 1] ^ (temp >> 1) ^ (2567483615U & -(temp & 1));
  }

 public:
  MersenneTwister(unsigned int seed = 0) : index(0) {
    MT[0] = seed;
    for (int i = 1; i < MT_N; ++i)
      MT[i] = 1812433253U * (MT[i - 1] ^ (MT[i - 1] >> 30)) + i;
  }
  unsigned int operator()() {
    if (index == 0) generate();
    unsigned int res = MT[index++];
    index &= -(index != MT_N);
    res ^= res >> 11;
    res ^= (res << 7) & 2636928640U;
    res ^= (res << 15) & 4022730752U;
    res ^= res >> 18;
    return res;
  }
};
template <class Generator>
class Random {
 private:
  Generator gen;

 public:
  Random(unsigned int seed = 0) : gen(seed) {}
  unsigned int next_int32() { return gen(); }
  unsigned long long next_int64() {
    unsigned long long a = gen();
    return (a << 32) | gen();
  }
  int next_int() { return gen() >> 1; }
  int next_int(int N) { return gen() % N; }
  int next_int(int low, int high) {
    unsigned int range = high - low + 1;
    unsigned int rem = 4294967295U % range;
    unsigned int t;
    do {
      t = gen();
    } while (t < rem);
    return low + t % range;
  }
  double next_double() { return (double)gen() * (1.0 / 4294967295.0); }
  double next_double(double n) { return next_double() * n; }
  double next_double_exc() { return (double)gen() * (1.0 / 4294967296.0); }
  double next_double_exc(double n) { return next_double_exc() * n; }
  double next_gaussian(double mean = 0.0, double stddev = 1.0) {
    double u, v, r2;
    do {
      u = next_double(2.0) - 1.0;
      v = next_double(2.0) - 1.0;
      r2 = u * u + v * v;
    } while (r2 == 0.0 || r2 > 1.0);
    return (u * sqrt(-2.0 * log(r2) / r2)) * stddev + mean;
  }
  template <class T>
  void random_shuffle(T begin, T end) {
    for (unsigned int sz = end - begin; sz; --sz, ++begin) {
      T next = begin + next_int(sz);
      swap(*begin, *next);
    }
  }
};
Random<MersenneTwister> rnd;
const int MAX = 500;
int N, x[MAX], p[MAX];
void gen() {
  N = MAX;
  for (int i = 0; i < (N); i++) p[i] = rnd.next_int(1, 1000000);
  set<int> used;
  for (int i = 0; i < (N); i++) {
    while (true) {
      x[i] = rnd.next_int(1, 1000000);
      if (used.find(x[i]) == used.end()) break;
    }
    used.insert(x[i]);
  }
  sort(x, x + N);
}
vector<double> radius;
vector<int> s;
void relax(int i, int j) {
  int t = s[j];
  radius[i] =
      min(radius[i], (double)(x[i] - x[t]) * (x[i] - x[t]) / 4.0 / radius[t]);
}
double solve(int limit) {
  radius.clear();
  s.clear();
  double sum = 0;
  for (int i = 0; i < (N); i++) {
    radius.push_back(p[i]);
    for (int j = 0; j < (min((int)s.size(), limit)); j++)
      relax(i, s.size() - j - 1);
    while (s.size() && radius[s.back()] <= radius[i]) s.pop_back();
    s.push_back(i);
    sum += radius[i];
  }
  return sum;
}
void add(int _x, int _p) {
  x[N] = _x;
  p[N] = _p;
  ++N;
}
int main() {
  const int MIL = 1000000;
  int last = 500000;
  add(0, MIL);
  for (int i = 0; i < (300); i++) {
    int r = 305 - i;
    last += r;
    add(last, r);
    last += r;
  }
  add(MIL, MIL);
  printf("%d\n", N);
  for (int i = 0; i < (N); i++) printf("%d %d\n", x[i], p[i]);
  return 0;
}
