using System;
using System.Text;

namespace A328078 {
    class Program {
        static void Main(string[] args) {
            Rectangle root = Rectangle.BuildRoot();

            Console.WriteLine("{0} {1}", 0, Rectangle.Count);
            long width = 1;
            for (int n=1; n<=25; n++) {
                int d = (n - 1) % 2;
                if (d==0) {
                    width *= 2;
                    Rectangle.Inflate();
                }

                for (int x=1; x<width; x+=2) {
                    Rectangle rect = root.Locate(d, x);
                    bool split = true;
                    while (rect!=null) {
                        if (split) {
                            rect = rect.Split(d, x);
                        }
                        rect = rect.Move(1-d);
                        if (rect!=null) {
                            rect = rect.Locate(d, x);
                        }
                        split = !split;
                    }
                }

                Console.WriteLine("{0} {1}", n, Rectangle.Count);
            }
        }
    }

    public class Rectangle {
        public static Rectangle BuildRoot() {
            Rectangle seed = new Rectangle();
            for (int d=0; d<2; d++) {
                seed.max[d] = 1;
            }
            return seed;
        }

        public static void Inflate() {
            Rectangle rect = First;
            while (rect!=null) {
                for (int d=0; d<2; d++) {
                    rect.min[d] *= 2;
                    rect.max[d] *= 2;
                }

                rect = rect.other;
            }
        }

        public Rectangle Locate(int d, int x) {
            if (this.min[d] < x && x < this.max[d]) {
                if (this.children==null) {
                    return this;
                } else {
                    foreach (Rectangle child in this.children) {
                        Rectangle loc = child.Locate(d, x);
                        if (loc!=null) {
                            return loc;
                        }
                    }
                    throw new ApplicationException("bug!");
                }
            } else {
                return null;
            }
        }

        public Rectangle Split(int d, int x) {
            if (this.children!=null) {
                throw new ApplicationException("bug!");
            }

            Count--;

            this.children = new Rectangle[2];
            for (int c=0; c<2; c++) {
                this.children[c] = new Rectangle();
                Array.Copy(this.min, this.children[c].min, 2);
                Array.Copy(this.max, this.children[c].max, 2);
                Array.Copy(this.neighbours, this.children[c].neighbours, 2);
            }

            this.children[0].neighbours[d] = this.children[1];
            this.children[0].max[d] = x;
            this.children[1].min[d] = x;

            return this.children[0];
        }

        public Rectangle Move(int d) {
            return this.neighbours[d];
        }

        private Rectangle() {
            this.other = First;
            First = this;
            Count++;
        }

        private long[] min = new long[2];
        private long[] max = new long[2];
        private Rectangle[] neighbours = new Rectangle[2];
        private Rectangle[] children = null;
        private Rectangle other = null;

        public static long Count = 0;
        private static Rectangle First = null;
    }
}