public Shard(Coord ul, Coord ur, Coord ll, Coord lr)
 {
     _ul = ul;
       _ur = ur;
       _ll = ll;
       _lr = lr;
 }

        private static void InitialiseInhab(Inhabitant thing,Room room,AMaterialStats stats)
        {
            int trytimes = 0;
            bool done = false;
            Coord size = new Coord(3, 3);

            while (!done && trytimes < 20)
            {
                //Random distribution HACK! u can make more distribution types
                int tryx = MyRandom.Random.Next(0, room.RoomOccupiedGrid.GetLength(0) - size.X);
                int tryy = MyRandom.Random.Next(0, room.RoomOccupiedGrid.GetLength(1) - size.Y);

                if (CheckClear(new Coord(tryx, tryy), size,room.RoomOccupiedGrid))
                {
                    MakeNotCLear(new Coord(tryx, tryy), size, room.RoomOccupiedGrid);

                    thing.Initialise(size - new Coord(1, 1)
                   , room.Position + (new Vector2(tryx+1.5f, tryy+1.5f)*Globals.SmallGridSize)
                   , room.RoomAmbient.RoomColour, room.RoomAmbient.GlowColour, stats
                   , room.RoomAmbient.RoomTileset);
                    done = true;
                }
                trytimes++;
            }
        }

        private static void Main()
        {
            var input = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
            var n = input[0];
            var coord0 = new Coord(input[1], input[2]);
            var rgcoord = new HashSet<Coord>();
            for (var i = 0; i < n; i++)
            {
                input = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
                rgcoord.Add(new Coord(input[0], input[1]));
            }

            var d = 0;
            while (rgcoord.Any())
            {
                d++;
                var coord = rgcoord.First();
                var vX = coord.x - coord0.x;
                var vY = coord.y - coord0.y;

                foreach (var coordT in rgcoord.ToList())
                {
                    if (vY*(coordT.x - coord0.x) == vX*(coordT.y - coord0.y))
                        rgcoord.Remove(coordT);
                }
            }

            Console.WriteLine(d);
        }

        private static void DrawTargetMark(Unit currentUnit, Coord target, bool toShow)
        {
            if (toShow)
            {
                ZBuffer.ReadBuffer("targetBuffer", target.X, target.Y, 3, 3);

                var buffer = ZBuffer.BackupBuffer("defaultBuffer");
                ZIOX.OutputType = ZIOX.OutputTypeEnum.Buffer;
                ZIOX.BufferName = "defaultBuffer";

                var targetColor = IsTargetOnSoldier(currentUnit, target) ? Color.Yellow : Color.Cyan;

                ZIOX.Print(target.X-1, target.Y-1, (char)Tools.Get_Ascii_Byte('┌'), targetColor);
                ZIOX.Print(target.X+1, target.Y-1, (char)Tools.Get_Ascii_Byte('┐'), targetColor);
                ZIOX.Print(target.X-1, target.Y+1, (char)Tools.Get_Ascii_Byte('└'), targetColor);
                ZIOX.Print(target.X+1, target.Y+1, (char)Tools.Get_Ascii_Byte('┘'), targetColor);

                MapRender.DrawVisibleUnits(currentUnit);
                ZIOX.OutputType = ZIOX.OutputTypeEnum.Direct;

                ZBuffer.WriteBuffer("defaultBuffer", UIConfig.GameAreaRect.Left, UIConfig.GameAreaRect.Top);
                ZBuffer.SaveBuffer("defaultBuffer", buffer);
            }
            else
            {
                ZBuffer.WriteBuffer("targetBuffer", target.X, target.Y);
            }
        }

        public static Coord DoTargetAction(Unit unit)
        {
            var exitFlag = false;

            var target = new Coord(unit.Position.X, unit.Position.Y);
            DrawTargetMark(unit, target, true);

            while (!exitFlag)
            {
                var key = ZInput.ReadKey();
                var oldTarget = new Coord(target.X, target.Y);

                switch (key)
                {
                    case ConsoleKey.LeftArrow	:	MoveTarget(target, -1,  0);		break;
                    case ConsoleKey.RightArrow	:	MoveTarget(target, +1,  0);		break;
                    case ConsoleKey.UpArrow		:	MoveTarget(target,  0, -1);		break;
                    case ConsoleKey.DownArrow	:	MoveTarget(target,  0, +1);		break;

                    case ConsoleKey.Enter		:	return target;		break;
                    case ConsoleKey.Escape		:	exitFlag = true;	break;
                }

                if (!oldTarget.Equals(target))
                {
                    DrawTargetMark(unit, oldTarget, false);
                    DrawTargetMark(unit, target, true);
                }
            }

            return null;
        }

 public Room(Coord aTopLeft, int aHeight, int aWidth, Direction aDirection)
 {
     iTopLeft = aTopLeft;
     iHeight = aHeight;
     iWidth = aWidth;
     iDoorLocation = aDirection;
 }

        private static void DFS(Coord coord, Coord target, long sum, int[,] lab)
        {
            //if (!visited.Contains(coord))
            //{
                visited.Add(coord);

                if (coord.Equals(target))
                {
                    results.Add(sum);
                    return;
                }

                if (lab[coord.X, coord.Y] == 1)
                {
                    sum += 1;
                }

                if (coord.X + 1 < lab.GetLength(0))
                {
                    

                    DFS(new Coord(coord.X + 1, coord.Y), target, sum, lab);
                }
                if (coord.Y + 1 < lab.GetLength(1))
                {

                    DFS(new Coord(coord.X, coord.Y + 1), target, sum, lab);
                }
            //}
        }

 protected Pieces(string name, Couleur couleur, Coord coord)
 {
     Name = name;
     Couleur = couleur;
     Coord = coord;
     Depart = true;
     Captured = false;
 }

 public FlamingLongSword(string name = "Flaming Long Sword", Coord position = new Coord())
     : base(name,
            position: position,
            specialAttack: Weapon.WeaponSpecialAttacks.Flaming,
            specialAttackDescription: Weapon.WeaponSpecialAttacks.Flaming.WeaponDescription())
 {
     
 }

        public StackItemTest(   Color color = new Color(),
                                string description = "Stackable Item",
                                Coord position = new Coord(),
                                int uses = _UnlimitedUses)
            :base("Stack Item", "s", color: color, cost: 1, description: description, position: position, uses: uses)
        {

        }

 public ShardSet(Coord ul, Coord lr, int n)
 {
     var ur = new Coord(ul.X, lr.Y);
       var ll = new Coord(lr.X, ul.Y);
       _set = Split(new Shard(ul, ur, ll, lr), n);
       Console.WriteLine("n: " + n);
       Console.WriteLine("#shards: " + _set.Count);
 }

 public static bool IsTargetOnSoldier(Unit currentUnit, Coord target)
 {
     foreach (var team in MainGame.Teams)
         foreach (var unit in team.Units.Where(a => a.Name != currentUnit.Name))
             if (target.Equals(unit.Position))
                 return true;
     return false;
 }

        public static Item GenerateByBuilderType(  Type type, 
                                            Pg.Level level = Pg.Level.Novice, 
                                            Coord position = new Coord())
        {

            return Generators.ContainsKey(type)
                ? Generators[type].GenerateRandom(level, position)
                : null;
        }

        public byte[] Render(Coord coord, string format, int tileWidth, int tileHeight)
        {
            ProxyProvider proxy;
            if (!this._proxyDictionary.TryGetValue(format.ToString(), out proxy))
                throw new InvalidTileFormatException(
                    string.Format("Invalid tile FORMAT {0}", format)
                );

            return proxy.Render(coord, format, tileWidth, tileHeight);
        }

        public Wall(Coord position)
            : base("Wall", 
                   "█", 
                   Color.LightGray, 
                   false, 
                   true,
                   "A rock wall",
                   position)
        {

        }

        public void Reprair() {
            Coord[] natural =  new Coord[10];
            Coord[] stretchability = new Coord[10];
            Coord[] shrinkability = new Coord[10];
            int[] breaks = new int[10];
            // Подготовить массивы с характеристиками компонентов
            // ...

            // Определить, где должны быть точки разрыва
            int breakCount = _compositor.Compose(natural, stretchability, shrinkability,
                _componentCount, _lineWidth, breaks);
        }

        private void GetAdjacentCoords(List<Coord> AdjacentCoords, PixelData Canvas, Coord coord, System.Drawing.Color SeekColor)
        {
            if (coord.X >= 0 && coord.X < Canvas.Width && coord.Y >= 0 && coord.Y < Canvas.Height && Canvas[coord.X, coord.Y] == SeekColor) {
                if (!AdjacentCoords.Contains(coord)) {
                    AdjacentCoords.Add(coord);

                    GetAdjacentCoords(AdjacentCoords, Canvas, new Coord(coord.X - 1, coord.Y), SeekColor);
                    GetAdjacentCoords(AdjacentCoords, Canvas, new Coord(coord.X + 1, coord.Y), SeekColor);
                    GetAdjacentCoords(AdjacentCoords, Canvas, new Coord(coord.X, coord.Y - 1), SeekColor);
                    GetAdjacentCoords(AdjacentCoords, Canvas, new Coord(coord.X, coord.Y + 1), SeekColor);
                }
            }
        }

        public WoodenShield(string name = "Wooden Shield", Coord position = new Coord())
            : base( name, 
                    Shield.DefaultSymbol, 
                    Color.Brown,
                    1,
                    0,
                    description: "A wooden small shield",
                    cost: 1,
                    weight: 2,
                    position: position)
        {

        }

 static int play(int[,] game, Coord c)
 {
     if (1 == game[c.x, c.y])
     {
         return 1;
     }
     else if (0 == game[c.x, c.y])
     {
         game[c.x, c.y] = -1;
         return 0;
     }
     else return -1;
 }

        //  Octant data
        //
        //    \ 1 | 2 /
        //   8 \  |  / 3
        //   -----+-----
        //   7 /  |  \ 4
        //    / 6 | 5 \
        //
        //  1 = NNW, 2 =NNE, 3=ENE, 4=ESE, 5=SSE, 6=SSW, 7=WSW, 8 = WNW
        /// <summary>
        /// Start here: go through all the octants which surround the player to determine which open cells are visible
        /// </summary>
        public static List<Coord> GetVisibleCells(Level level, Coord playerPosition, ObjectHeight playerHeight)
        {
            MapSize = level.Size;
            Map = level.Map;
            PlayerPos = playerPosition;
            PlayerHeight = playerHeight;

            VisiblePoints = new List<Coord>{ PlayerPos };
            foreach (var octant in VisibleOctants)
                ScanOctant(1, octant, 1.0, 0.0);

            return VisiblePoints;
        }