Problem: Martha — as a professional problemsetter — proposed a problem for a world-class contest. This is the problem statement:

Tomorrow is Nadia's birthday, and Bardia (her brother) is assigned to make the balloons ready!

There are n balloons (initially empty) that are tied to a straight line on certain positions x1, x2, ..., xn. Bardia inflates the balloons from left to right. As a result, i-th balloon gets bigger and bigger until its radius reaches the pressure endurance pi or it touches another previously-inflated balloon.

<image>

While Bardia was busy with the balloons, he wondered "What will be the sum of radius of balloons after all of the balloons are inflated?". Being a nerdy type of guy, he is now thinking about the problem instead of preparing his sister's birthday. Calculate the answer to Bardia's problem so that Nadia's birthday won't be balloon-less.

Artha — Martha's student — claimed his solution got accepted. Martha (being his teacher for a long time!) knew he couldn't have solved the problem for real and thus thinks there is something wrong with the testcases. Artha isn't anyhow logical, which means there is no way for Martha to explain the wrong point in his algorithm. So, the only way is to find a testcase to prove him wrong!

Artha's pseudo-code is shown below:

<image>

You should output a small testcase for the problem such that Artha's algorithm is incorrect. The algorithm's output is considered correct if it differs from the correct value by no more than 1.

Input

Please pay attention! No input will be given to your program for this problem. So you do not have to read from the input anything.

Output

You should output the generated small testcase (which Artha's solution doesn't get it right). It should be in the following format:

  * First line must contain the only number n (1 ≤ n ≤ 500). 
  * The i-th of the next n lines should contain the description of the i-th balloon — two space-separated integers xi, pi (1 ≤ pi ≤ 106, 0 ≤ x1 < x2 < ... < xn ≤ 106). 

Examples

Note

The testcase depicted in the figure above (just showing how output should be formatted):
    
    
      
    4  
    0 9  
    6 3  
    12 7  
    17 1  
    

Solution (in CPP):

Solution:
#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;
}