using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace D6._1
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length < 2) return;
            if (File.Exists(args[0]) == false) return;
            if (uint.TryParse(args[1], out uint size) == false) return;

            var coordinates = new List<((uint x, uint y) coord, bool isInfinite)>();
            var file = File.OpenText(args[0]);

            do
            {
                var line = file.ReadLine();
                if (line == null) break;

                var cl = line.Split(", ");
                coordinates.Add(((uint.Parse(cl[0]), uint.Parse(cl[1])), false));
            } while (true);

            var area = new int[coordinates.Count];

            fillMapArea(size, coordinates, area);

            flagPointOnEdges(size, coordinates);

            int maxArea = findMaxCoveredArea(coordinates, area);

            Console.WriteLine($"Answer : {maxArea}");
        }

        private static int findMaxCoveredArea(List<((uint x, uint y) coord, bool isInfinite)> coordinates, int[] area)
        {
            int maxArea = 0;
            for (int i = 0; i < area.Length; ++i)
            {
                if (coordinates.ElementAt(i).isInfinite) continue;

                if (area[i] > maxArea) maxArea = area[i];
            }

            return maxArea;
        }

        private static void flagPointOnEdges(uint size, List<((uint x, uint y) coord, bool isInfinite)> coordinates)
        {
            for (uint i = 0; i < size; ++i)
            {
                var x0yi = GetClosest(coordinates, 0, i);
                MarkInfinite(coordinates, x0yi);

                var xiy0 = GetClosest(coordinates, i, 0);
                MarkInfinite(coordinates, xiy0);

                var xsizeyi = GetClosest(coordinates, size, i);
                MarkInfinite(coordinates, xsizeyi);

                var xiysize = GetClosest(coordinates, i, size);
                MarkInfinite(coordinates, xiysize);
            }
        }

        private static void fillMapArea(uint size, List<((uint x, uint y) coord, bool isInfinite)> coordinates, int[] area)
        {
            for (uint x = 0; x < size; x++)
            {
                for (uint y = 0; y < size; y++)
                {
                    var closest = GetClosest(coordinates, x, y);

                    area[closest]++;
                }
            }
        }

        private static int GetClosest(List<((uint x, uint y) coord, bool isInfinite)> coordinates, uint x, uint y)
        {
            long lowest = int.MaxValue;
            int lowestId = 0;
            for (int i = 0; i < coordinates.Count; i++)
            {
                var coord = coordinates[i];
                var manhattan = Math.Abs((int)x - (int)coord.coord.x) + Math.Abs((int)y - (int)coord.coord.y);
                if (manhattan < lowest)
                {
                    lowest = manhattan;
                    lowestId = i;
                }
            }
            return lowestId;
        }

        private static void MarkInfinite(List<((uint x, uint y) coord, bool isInfinite)> coordinates, int id)
        {
            var coord = coordinates[id];
            coord.isInfinite = true;
            coordinates[id] = coord;
        }
    }
}