using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

namespace deme
{
    class Simbolis
    {
        public char x { get; private set; }

        public Simbolis()
        {
            x = ' ';
        }

        // Priskiria klasės kintamiesiems reikšmes.
        public Simbolis(char xx)
        {
            x = xx;
        }

        public override string ToString()
        {
            string eilute;
            eilute = string.Format("{0, 4}", x);
            return eilute;
        }
        // Palyginimo operatorius.

        public static bool operator ==(Simbolis pirmas, char antras)
        {
            return pirmas.x == antras;
        }

        public static bool operator !=(Simbolis pirmas, char antras)
        {
            return pirmas.x != antras;
        }
        public override bool Equals(object obj)
        {
            Simbolis Item = obj as Simbolis;
            return Item.x == this.x;
        }
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        //------------------------------------------------------------
    }
    class Plotai
    {
        const int EilSk = 20;
        const int StSk = 70;

        private Simbolis[,] Komp;
        public int nn { get; set; } // eilučių skaičius
        public int mm { get; set; } // stulpelių skaičius
        public Plotai()
        {
            nn = 0;
            mm = 0;
            Komp = new Simbolis[EilSk, StSk];
        }
        //----------------------------------------------------------------
        public void Dėti(int i, int j, Simbolis r)
        {
            Komp[i, j] = r;
        }
        //---------------------------------------------------------------
        public Simbolis Imti(int i, int j)
        {
            return Komp[i, j];
        }

        //------------------------------------------------------------
        public void PakeistiSimboli(int nr, int nr1, Simbolis mok) { Komp[nr,nr1] = mok; }
        //------------------------------------------------------------
        public void RikiuotiMin()
        {
            Simbolis mok = new Simbolis('*');
            Random Rand=new Random();
            for (int i = 0; i < nn*mm/3; i++)
            {
                int ii = Rand.Next(0,nn);
                int jj = Rand.Next(0, mm);
                if (Imti(ii, jj) != mok)
                    PakeistiSimboli(ii, jj, mok);
                else
                    i--;
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            const string CFr = "..\\..\\Rezultatai.txt";
            if (File.Exists(CFr))
                File.Delete(CFr);

            Plotai sodas = new Plotai();
            int  ilgiausiosDemesIlgis=0;
            int k=0;
            int kk=0;
            Skaityti(sodas);

            Spausdinti(CFr, sodas, "Pradiniai");
            sodas.RikiuotiMin(); // random generatorius
            Spausdinti(CFr, sodas, "Pakeista");
            SkaiciuojaSimbolius(sodas);
            ArLangeliaiNuspalvinti(sodas, out ilgiausiosDemesIlgis,out  k,out  kk);
            Console.WriteLine("{0} : {1} ,{2}",ilgiausiosDemesIlgis,k,kk);
        }
        //-----------------------------------------------------------------------
        static void Skaityti(Plotai sodas)
        {
                sodas.nn = int.Parse(Console.ReadLine());
                sodas.mm = int.Parse(Console.ReadLine());
                for (int i = 0; i < sodas.nn; i++)
                {
                    for (int j = 0; j < sodas.mm; j++)
                    {
                        char a1 = '.';

                        Simbolis ob = new Simbolis(a1);
                        sodas.Dėti(i, j, ob);
                }
            }
        }
        //------------------------------------------------------------
        //Spausdina konteinerio duomenis faile lentele.
        //------------------------------------------------------------
        static void Spausdinti(string fv, Plotai sodas, string antraštė)
        {
            string bruksnys = new string('-', 42);
            using (var fr = File.AppendText(fv))
            {
                fr.WriteLine(antraštė);
                Console.WriteLine(antraštė);
                fr.WriteLine(bruksnys);
                Console.WriteLine(bruksnys);
                for (int i = 0; i < sodas.nn; i++)
                {
                    for (int j = 0; j < sodas.mm; j++)
                    {
                        fr.Write("{0}", sodas.Imti(i, j).ToString());
                        Console.Write("{0}", sodas.Imti(i, j).ToString());
                    }
                    fr.WriteLine();
                    Console.WriteLine();
                }
                fr.WriteLine(bruksnys);
                Console.WriteLine(bruksnys);
            }
        }
        //------------------------------------------------------------
        static void SkaiciuojaSimbolius( Plotai sodas)
        {
            int [,] plotas=new int [100,100];
            int[] plotai = new int[100];
            int kiek = 0;
            //int kiek1 = 0;

            for (int i = 0; i < sodas.nn; i++)
            {
                kiek = 0;
                for (int j = 0; j < sodas.mm; j++)
                {
                    if (sodas.Imti(i, j) == '*'
                        || sodas.Imti(i, j) == '*' && j != sodas.mm && sodas.Imti(i, j + 1) == '*'
                        || sodas.Imti(i, j) == '*' && j != sodas.nn && sodas.Imti(i + 1, j) == '*'
                        || sodas.Imti(i, j) == '*' && j != sodas.mm && j != sodas.nn && sodas.Imti(i + 1, j + 1) == '*')
                    {
                        kiek++;
                        plotas[i, kiek] = j;
                    }
                }
                plotas[i, 0] = kiek;
            }
            for (int i = 0; i < sodas.nn; i++)
            {
                // int kiekl = 0;
                for (int j = 1; j <= plotas[i, 0]; j++)
                    Console.Write("  {0}", plotas[i, j]);
                Console.WriteLine();

            }
        }
        //Jeigu langelis, kurio koordinatės i ir j yra nuspalintas ir jeigu i ir j nėra lygu x ir y:Jeigu
        // tas langelis jau nėra pridėtas į šitą dėmę:
        //Pridėti langelį į tikrinamųLangelių list'ą
        static void Patikrinti(Plotai sodas, int x, int y, ref List<List<int>> tikrinamasTaskas)
        {
            for (int i = x-1; i <= x+1; i++)
            {
                for(int j=y-1; j<=y+1; j++)
                {
                    if (i >= 0 && j >= 0 && i < sodas.nn && j < sodas.mm)
                    {
             //           Console.Write(sodas.Imti(i, j));
                        if (sodas.Imti(i, j) == '*' && !(i == x && j == y))
                        {
             //               Console.Write(" [" + i + ";" + j + "] ");
                            bool arYraTaskas = false;
                            List<int> sublistas = new List<int>();
                            for (int k = 0; k < tikrinamasTaskas.Count; k++)
                            {
                                if (tikrinamasTaskas[k][0] == i && tikrinamasTaskas[k][1] == j)

                                    arYraTaskas = true;
                            }
                            if (!arYraTaskas)
                            {
                                sublistas.Add(i);
                                sublistas.Add(j);
                                tikrinamasTaskas.Add(sublistas);
                            }
                        }
                    }
                }
            }
        }
        static void ArLangeliaiNuspalvinti(Plotai sodas, out int ilgiausiosDemesIlgis,out int k,out int kk)
        {
             ilgiausiosDemesIlgis = 0;
             k = 0; kk = 0;
            for (int i=0; i<sodas.nn; i++)    // eini per kiekvieną langelį; i - "ciklo kintamasis"
            {

                for(int j=0; j<sodas.mm; j++)
                {
                    List<List<int>> tikrinamiLangeliai = new List<List<int>>();
                    List<int> sublist = new List<int>();
                        // tikrinamiLangeliai - šiuo metu tikrinamų langelių sąrašas
                    if (sodas.Imti(i, j) == '*')
                    {
                        sublist.Add(i);
                        sublist.Add(j);

                        tikrinamiLangeliai.Add(sublist);
                    }      // kad kai einam per visus langelius, bent tą langelį (jei jis nuspalvintas), ant kurio dabar "užėjom" patikrintų
                        for (int jj=0; jj<tikrinamiLangeliai.Count; jj++)       // eiti per visus langelius, kuriuos reikės tikrint (pastabaa: tikrinant langelius, gali atsirasti dar naujų tikrinamiLangeliai, . ciklo kintamasis j
                        {
                            Patikrinti(sodas, tikrinamiLangeliai[jj][0], tikrinamiLangeliai[jj][1], ref tikrinamiLangeliai);
        //                    Console.Write("s ");

                                // Jeigu tikrinamasis langelis turėjo kokių langelių, kurie tiko, juos reikės pridėti prie tikrinamiLangeliai list'o (greičiausiai tai implementuoti geriausia Patikrinti methode (nebūtinai))
                        }
                    Console.WriteLine();
                    Console.WriteLine("kazkas " + tikrinamiLangeliai.Count());
                       if (tikrinamiLangeliai.Count > ilgiausiosDemesIlgis)
                        {
                            k = i;
                            kk = j;
                            ilgiausiosDemesIlgis = tikrinamiLangeliai.Count;
                        }
                        //Jei didžiausia dėmė: atsiminti dėmės ilgį, atsiminti visilangeliai[i] vietą (kadangi reikia bent vieną dėmės tašką išvesti)
                    }
             }
        }
    }
}