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

namespace ConsoleApplication1
{
    class Program
    {
        static int N,equal;
        static string board;
        static List<int> position = new List<int>();

        static void Main(string[] args)
        {
            N = Convert.ToInt32(Console.ReadLine());
            board = Console.ReadLine();

            for (int i = 0; i < board.Length; ++i)
                if (board[i] == '*')
                    position.Add(i+1);

            for(int a=0; a<position.Count; ++a)
                 for(int b=a+1; b<position.Count; ++b)
                     for(int c=b+1; c<position.Count; ++c)
                         for(int d=c+1; d<position.Count; ++d)
                             for(int e=c+1; e<position.Count; ++e)
                             {
                                 equal = position[b]-position[a];
                                 if (position[c] - position[b] == equal && position[d] - position[c] == equal && position[e] - position[d] == equal)
                                 {
                                     Console.WriteLine("yes");
                                     return;
                                 }
                              }

            Console.WriteLine("no");

        }

    }

}

using System;

namespace Task_A
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());

            string s = Console.ReadLine();

            bool b = false;

            for (int i = 0; i < n; i++)
            {
                if (s[i] == '*')
                {
                    for (int j = 1; j < 25; j++)
                    {
                        if (i + 4 * j < n)
                        {
                            if (s[i + j] == '*' &&
                                s[i + 2 * j] == '*' &&
                                s[i + 3 * j] == '*' &&
                                s[i + 4 * j] == '*')
                            {
                                b = true;
                                break;
                            }
                        }
                        else
                        {
                            break;
                        }
                    }
                }
            }

            if (b)
                Console.WriteLine("yes");
            else
                Console.WriteLine("no");
        }
    }
}

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

namespace TaskA
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            string s = Console.ReadLine();
            int FirstPlatform = s.IndexOf("*");

            if (FirstPlatform != -1)
            {
                int count = 0;

                for (int i = 1; i < (int)(n / 2); i++)
                {
                    for (int j = FirstPlatform; j < n; j++)
                    {
                        count = 0;
                        int t = j;
                        while (s[t] == '*')
                        {
                            count++;
                            t += i;

                            if (t >= n)
                            {
                                break;
                            }
                        }

                        if (count >= 5)
                        {
                            break;
                        }
                    }
                    if (count >= 5)
                    {
                        break;
                    }
                }

                if (count >= 5)
                {
                    Console.WriteLine("yes");
                }
                else
                    Console.WriteLine("no");
            }
            else
            {
                Console.WriteLine("no");
            }

        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace AKingofThieves
{
    class Program
    {
        static void Main(string[] args)
        {
            int N = int.Parse(Console.ReadLine());
            string sc = Console.ReadLine();
            bool[] b = new bool[N];
            for (int i = 0; i < N; i++)
            {
                b[i] = sc[i] == '*';
            }

            if (SpaceP(b, N - 1))
            {
                Console.WriteLine("yes");
            }
            else
            {
                Console.WriteLine("no");
            }

        }

        public static bool Spacesi(bool[] b,int count,int N,int ind,int paso,int indini)
        {
            if (count==4)
            {
                return true;
            }
            if (ind>N-paso)
            {
                return false;
            }

                if (b[ind] && b[ind + paso])
                {
                    count++;
                    return Spacesi(b, count, N, ind + paso, paso,indini);
                }
                else
                {

                    return Spacesi(b, 0, N,indini, paso + 1,indini);
                }
        }

        public static bool SpaceP(bool[] b, int N)
        {
            for (int i = 0; i < N; i++)
            {
                if (b[i])
                {
                    if (Spacesi(b, 0, N, i, 1, i))
                    {
                        return true;
                    }
                }
            }
            return false;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text.RegularExpressions;
using System.IO;
using System.Numerics;
using System.Globalization;
using System.Threading;

namespace probleme {
    class Program {
        class pereche {
            public int x;
            public int y;
            public pereche(int x, int y) {
                this.x = x;
                this.y = y;
            }
        }
        static void Main(string[] args) {

            //Console.SetIn(new StreamReader("file.in"));
            /*
            FileStream filestream = new FileStream("out.txt", FileMode.Create);
            var streamwriter = new StreamWriter(filestream);
            streamwriter.AutoFlush = true;
            Console.SetOut(streamwriter);
            */

            int n = int.Parse(Console.ReadLine());
            char[] v = Console.ReadLine().ToCharArray();
            bool ans = false;
            for (int i = 0; i < n; i++) {
                if (v[i] == '*') {
                    for (int j = i + 1; j < n; j++) {
                        if (v[j] == '*') {
                            int diff = j - i, p3 = j + diff, p4 = p3 + diff, p5 = p4 + diff;
                            if (p5 < n && v[p3] == '*' && v[p4] == '*' && v[p5] == '*') {
                                ans = true;
                            }
                        }
                    }
                }
            }
            Console.Write("{0}", (ans) ? "yes" : "no");

            //Console.ReadKey();
        }
    }
}

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

namespace RussianCodeCup
{
    class Program
    {
        static void Main(string[] args)
        {
            string tokens = Console.ReadLine();//.Split(' ');
//            int m, a;
            int n = int.Parse(tokens);
//            int m = int.Parse(tokens[1]);
//            int a = int.Parse(tokens[2]);
            string srt = Console.ReadLine();
            int s = n/4;
            bool flag = false;
            for (int i = 1; i <= s; i++)
            {
//                int st = 1;
                if (Solve(i, srt))
                {
                    flag = true;
                }
            }

            if (flag)
            {
                Console.WriteLine("yes");
            }
            else
            {
                Console.WriteLine("no");
            }

        }

        static public bool Solve(int step , string str)
        {
            int count = 0;
            int dl = str.Length - step*4;
            bool flag = false;
            for (int j = 0; j < dl; j++)
            {
                count = 0;
                for (int i = j; i < str.Length; i += step)
                {
                    if (str[i] == '*')
                    {
                        count++;
                    }
                    else
                    {
                        count = 0;
                    }
                    if (count>=5)
                    {
                        return true;
                    }
                }
            }
            return false;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace zepto
{
    class Program
    {

        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            string ans = "no";
            string s = Console.ReadLine();

            for (int i = 0; i < n; i++)
            {
                for (int jump = 1; jump < n; jump++)
                {
                    bool f = true;
                    for (int j = 0; j < 5; j++)
                    {
                        int a = i + j*jump;
                        if (a >= n || s[a] != '*')
                        {
                            f = false;
                            break;
                        }
                    }

                    if (!f) continue;
                    ans = "yes"; break;
                }
            }

            Console.WriteLine(ans);
        }
    }
}

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

namespace prA {

    class Program {
#if ONLINE_JUDGE
        private static readonly StreamReader reader = new StreamReader(Console.OpenStandardInput(1024 * 10), System.Text.Encoding.ASCII, false, 1024 * 10);
        private static readonly StreamWriter writer = new StreamWriter(Console.OpenStandardOutput(1024 * 10), System.Text.Encoding.ASCII, 1024 * 10);
#else
        private static readonly StreamWriter writer = new StreamWriter("output");
        private static readonly StreamReader reader = new StreamReader("input");
#endif
        static void Main(string[] args) {
            int n = Next();
            reader.ReadLine();
            string s = reader.ReadLine();
            bool ans = false;
            for(int i = 0; !ans && i < n; i++) {
                if(s[i] == '.')
                    continue;
                for(int d = i - 1; !ans && d > 0; d--) {
                    ans = i - d >= 0 && s[i - d] == '*' && i - 2 * d >= 0 && s[i - 2 * d] == '*' && i - 3 * d >= 0 && s[i - 3 * d] == '*' && i - 4 * d >= 0 && s[i - 4 * d] == '*';
                }
            }
            writer.Write(ans ? "yes" : "no");
            writer.Flush();
#if !ONLINE_JUDGE
            writer.Close();
#endif
        }
        private static int Next() {
            int c;
            int res = 0;
            do {
                c = reader.Read();
                if(c == -1)
                    return res;
            } while(c != '-' && (c < '0' || c > '9'));
            int sign = 1;
            if(c == '-') {
                sign = -1;
                c = reader.Read();
            }
            res = c - '0';
            while(true) {
                c = reader.Read();
                if(c < '0' || c > '9')
                    return res * sign;
                res *= 10;
                res += c - '0';
            }
        }
    }
}

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

// (づ°ω°)づﾐ★゜・。。・゜゜・。。・゜☆゜・。。・゜゜・。。・゜
public class Solver
{
    public void Solve()
    {
        int n = ReadInt();
        string s = ReadToken();
        for (int i = 1; i * 4 < n; i++)
            for (int j = 0; j + 4 * i < n; j++)
            {
                bool f = true;
                for (int k = 0; k < 5; k++)
                    if (s[j + k * i] == '.')
                        f = false;
                if (f)
                {
                    Write("yes");
                    return;
                }
            }
        Write("no");
    }

    #region Main

    protected static TextReader reader;
    protected static TextWriter writer;
    static void Main()
    {
#if DEBUG
        reader = new StreamReader("..\\..\\input.txt");
        writer = Console.Out;
        //writer = new StreamWriter("..\\..\\output.txt");
#else
        reader = new StreamReader(Console.OpenStandardInput());
        writer = new StreamWriter(Console.OpenStandardOutput());
        //reader = new StreamReader("cycle.in");
        //writer = new StreamWriter("cycle.out");
#endif
        try
        {
//            var thread = new Thread(new Solver().Solve, 1024 * 1024 * 128);
//            thread.Start();
//            thread.Join();
            new Solver().Solve();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
#if DEBUG
#else
            throw;
#endif
        }
        reader.Close();
        writer.Close();
    }

    #endregion

    #region Read / Write
    private static Queue<string> currentLineTokens = new Queue<string>();
    private static string[] ReadAndSplitLine() {return reader.ReadLine().Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);}
    public static string ReadToken(){while (currentLineTokens.Count == 0)currentLineTokens = new Queue<string>(ReadAndSplitLine());return currentLineTokens.Dequeue();}
    public static int ReadInt(){return int.Parse(ReadToken());}
    public static long ReadLong(){return long.Parse(ReadToken());}
    public static double ReadDouble(){return double.Parse(ReadToken(), CultureInfo.InvariantCulture);}
    public static int[] ReadIntArray(){return ReadAndSplitLine().Select(int.Parse).ToArray();}
    public static long[] ReadLongArray(){return ReadAndSplitLine().Select(long.Parse).ToArray();}
    public static double[] ReadDoubleArray(){return ReadAndSplitLine().Select(s => double.Parse(s, CultureInfo.InvariantCulture)).ToArray();}
    public static int[][] ReadIntMatrix(int numberOfRows){int[][] matrix = new int[numberOfRows][];for (int i = 0; i < numberOfRows; i++)matrix[i] = ReadIntArray();return matrix;}
    public static int[][] ReadAndTransposeIntMatrix(int numberOfRows){int[][] matrix = ReadIntMatrix(numberOfRows);int[][] ret = new int[matrix[0].Length][];
        for (int i = 0; i < ret.Length; i++){ret[i] = new int[numberOfRows];for (int j = 0; j < numberOfRows; j++)ret[i][j] = matrix[j][i];}return ret;}
    public static string[] ReadLines(int quantity){string[] lines = new string[quantity];for (int i = 0; i < quantity; i++)lines[i] = reader.ReadLine().Trim();return lines;}
    public static void WriteArray<T>(IEnumerable<T> array){writer.WriteLine(string.Join(" ", array));}
    public static void Write(params object[] array){WriteArray(array);}
    public static void WriteLines<T>(IEnumerable<T> array){foreach (var a in array)writer.WriteLine(a);}
    private class SDictionary<TKey, TValue> : Dictionary<TKey, TValue>{public new TValue this[TKey key]{
        get { return ContainsKey(key) ? base[key] : default(TValue); }set { base[key] = value; }}}
    private static T[] Init<T>(int size) where T : new(){var ret = new T[size];for (int i = 0; i < size; i++)ret[i] = new T();return ret;}
    #endregion
}

using System;
using System.Collections.Generic;
using System.Collections.Concurrent;
using System.Linq;
using System.Collections.Specialized;
using System.Collections;

namespace CodeForces
{
    class Program
    {
        static void Main() {
            int n = ReadNumber();
            string map = Console.ReadLine();
            for (int i = 0; i < n - 4; i++) {
                for (int j = 1; j < n; j++) {
                    bool suc = true;
                    for (int k = 0; k < 5; k++) {
                        if (i + k * j >= n || map[i + k * j] == '.')
                            suc = false;
                    }
                    if (suc) {
                        Console.WriteLine("yes");
                        return;
                    }
                }
            }
            Console.WriteLine("no");
        }

        static int ReadNumber() {
            return int.Parse(Console.ReadLine());
        }

        static int[] ReadIntNumbers() {
            string s = Console.ReadLine();
            string[] sa = s.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            int[] output = new int[sa.Length];
            for (int i = 0; i < sa.Length; i++) {
                output[i] = int.Parse(sa[i]);
            }
            return output;
        }

        static double[] ReadDoubleNumbers() {
            string s = Console.ReadLine().Replace('.',',');
            string[] sa = s.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            double[] output = new double[sa.Length];
            for (int i = 0; i < sa.Length; i++) {
                output[i] = double.Parse(sa[i]);
            }
            return output;
        }

    }
}

using System;
using System.Collections.Generic;

namespace A526{
	class Program{
		static void Main(string[] args){
            int n = int.Parse(Console.ReadLine());
            string level = Console.ReadLine();
            int currentLength = 1;

            while (currentLength * 4 < level.Length)
            {
                for(int i = 0; i < level.Length; i++)
                {
                    try
                    {
                        if (level[i + currentLength * 0] == '*'
                            && level[i + currentLength * 1] == '*'
                            && level[i + currentLength * 2] == '*'
                            && level[i + currentLength * 3] == '*'
                            && level[i + currentLength * 4] == '*')
                        {
                            Console.WriteLine("yes");
                            return;
                        }
                    } catch
                    {
                        break;
                    }
                }
                currentLength++;
            }
            Console.WriteLine("no");
		}
	}
}

using System;

namespace CodeRushA
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Int32.Parse(Console.ReadLine());
            string line = Console.ReadLine();

            for (int j = 1; j <= n - 1; ++j)
            {
                for (int i = 0; i < n; ++i)
                {
                    if (line[i] == '*' && i + j < n && line[i + j] == '*' && i + j + j < n && line[i + j + j] == '*' && i + j + j + j < n && line[i + j + j + j] == '*' && i + j + j + j + j < n && line[i + j + j + j + j] == '*')
                    {
                        Console.WriteLine("yes");
                        return;
                    }
                }
            }
            Console.WriteLine("no");
        }
    }
}

using System;
using System.Linq;

namespace CSharp
{
    class _526A
    {
        public static void Main()
        {
            int n = int.Parse(Console.ReadLine());
            string s = Console.ReadLine();

            Console.WriteLine(Enumerable.Range(1, n).Any(d => Enumerable.Range(0, d).Any(r => string.Concat(Enumerable.Range(0, n).Where(i => i % d == r).Select(i => s[i])).Contains("*****"))) ? "yes" : "no");
        }
    }
}

using System;

public class KingOfThieves
{

	static public void Print(int n,int s,int k,int d)
	{
		string markers="";
		for(int i=0;i<s;++i)markers+=".";
		for(int k2=0;k2<=4;++k2)
			{
			if(k2==k)	markers+="|";
			else		markers+="-";
			for(int i=1;i<d ;++i)markers+=".";
			}
		for(int i=d;s+4*d+i<n;++i)markers+=".";
		Console.WriteLine(markers);
	}

	static public void Main()
	{
		int n=Convert.ToInt32(Console.ReadLine());

		if(n<1 || n>100){Console.WriteLine("no"); return;}

	/*	Random r = new Random (Guid.NewGuid().ToByteArray()[0]);
		for(int t=0;t<100;++t)
		{

		int M=5+r.Next()%15;
		string input="";
		for(int m=0;m<M;++m)
			input	+=	(r.Next()%2>0)?"*":".";
*/

		string input=Console.ReadLine();

		if(n!=input.Length){Console.WriteLine("no"); return;}
		bool end=false;
		for(int d=n/4;d>=1 && !end;--d)
		{
			for(int s=0;s<n-4*d && !end;++s)
			{
				bool pit=false;

				int k;
				for(k=0;k<=4 ;++k)
				{

				//	Console.WriteLine(input);
				//	Print(n,s,k,d);

					if(input[s+k*d]!='*')
					{
				//		Console.WriteLine("pit");
						pit=true;
					}
				//	else Console.WriteLine("No pit");
				}

				if(pit==false)
				{
				//	Console.WriteLine(input);Print(n,s,k,d);
				Console.WriteLine("yes"); end=true;
				}
			}

		}
		if(end==false)
		{
			//Console.WriteLine(input);
			Console.WriteLine("no");
		}

	//	}

	}

}

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

namespace CF526A {
    class Program {
        static void Main(string[] args) {
            int seg = int.Parse(Console.ReadLine());
            char[] segments = new char[seg];
            List<int> platPos = new List<int>();

            for(int i = 0; i < seg; i++) {
                char segType = (char)Console.Read();
                if(segType == '*') {
                    platPos.Add(i);
                }
                segments[i] = segType;
            }

            if(platPos.Count < 5) {
                Console.WriteLine("no");
                return;
            }

            bool isPossible = false;
            for(int i = 0, startPlat = platPos[i]; i < platPos.Count - 4; startPlat = platPos[++i]) {
                for(int jump = 1; startPlat + jump < seg; jump++) {
                    int count = 1;
                    //Console.WriteLine("Jumplength = " + jump);
                    for(int j = 1; startPlat + j*jump < seg; j++) { //index through segments by jump length from given platform
                        //Console.WriteLine("Jumped to pos " + (startPlat + j * jump) + " found " + segments[startPlat + j * jump]);
                        if(segments[startPlat + j*jump] == '*') {
                            count++;
                        } else {
                            j = seg;
                        }
                    }
                    if(count >= 5) {
                        isPossible = true;
                        jump = seg;
                        i = platPos.Count - 4;
                    }
                }
            }

            if(isPossible) {
                Console.WriteLine("yes");
            } else {
                Console.WriteLine("no");
            }
        }
    }
}

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

namespace ZeptoLab_Code_Rush_2015
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());
            string s = Console.ReadLine();
            int l = 0, kol = 0;
            bool f = false;
            for (int i = 0; i < s.Length; i++)
            {
                kol = 0;
                l++;
                for (int j = 0; j < s.Length; j++)
                {

                    kol = 0;
                    if (s[j] == '*')
                    {
                        for (int k = j; k < s.Length; k += l)
                        {

                            if (s[k]=='*') kol++;
                            else kol = 0;
                            if (kol == 5)
                            {
                                f = true;
                                break;
                            }
                        }

                        if (f)
                        {
                            break;
                        }
                    }
                }
            }

            if (f)
            {
                Console.WriteLine("Yes");
            }
            else
            {
                Console.WriteLine("No");
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace Zad_A
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = Convert.ToInt16(Console.ReadLine());
            string s = Console.ReadLine();
            bool f = false;
            for (int i = 0; i < a - 3; i++)
            {
                if (s[i] == '*')
                {
                    for (int j = 1; j < a; j++)
                    {
                        if (i + j < a && i + 2 * j < a && i + 3 * j < a && i + 4 * j < a && s[i + j] == '*' && s[i + 2 * j] == '*' && s[i + 3 * j] == '*' && s[i + 4 * j] == '*')
                        {
                            f = true;
                            break;
                        }
                    }
                }
                if (f) break;
            }

            if (f) Console.WriteLine("yes");
            else Console.WriteLine("no");
        }
    }
}

using System;
using System.Text;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;

namespace WarmingUpC_Sharp
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = ReadInt();
            string level = Console.ReadLine();
            int pos = PosFirstPlatform(level), jumps = 0, count = 0;
            if (pos < 0)
            {
                Console.WriteLine("no");
                return;
            }
            for (int i = pos; i < n; i++)
            {
                if (level[i] == '.')
                    continue;
                jumps = 0;
                while (jumps < n - i)
                {
                    jumps++;
                    for (int j = i; j < n; j += jumps)
                    {
                        if (level[j] == '*')
                            count++;
                        else
                        {
                            if (count >= 5)
                                break;
                            count = 0;
                            break;
                        }
                    }
                    if (count >= 5)
                    {
                        Console.WriteLine("yes");
                        return;
                    }
                    count = 0;
                }
            }
            Console.WriteLine("no");
        }
        public static int PosFirstPlatform(string elem)
        {
            for (int i = 0; i < elem.Length; i++)
            {
                if (elem[i] == '*')
                    return i;
            }
            return -1;
        }
        public static void Swap<T>(ref T a, ref T b)
        {
            T t = a;
            a = b;
            b = t;
        }
        public static int ReadInt()
        {
            return int.Parse(Console.ReadLine());
        }
        public static long ReadLong()
        {
            return long.Parse(Console.ReadLine());
        }
        public static int[] ReadListIntegers()
        {
            return Array.ConvertAll<string, int>(Console.ReadLine().Split(' '), int.Parse);
        }
        public static long[] ReadListLongs()
        {
            return Array.ConvertAll<string, long>(Console.ReadLine().Split(' '), long.Parse);
        }
        public static string[] ReadArrayStrings()
        {
            return Console.ReadLine().Split(' ');
        }
    }
}

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
public class Codeforces
{
    protected static TextReader reader;
    protected static TextWriter writer;
    static void Main()
    {
        reader = new StreamReader(Console.OpenStandardInput(1024 * 10), System.Text.Encoding.ASCII, false, 1024 * 10);
        writer = new StreamWriter(Console.OpenStandardOutput(1024 * 10), System.Text.Encoding.ASCII, 1024 * 10);
        var n = ReadInt();
        var s = reader.ReadLine().ToCharArray();
        Array.Resize(ref s, 1000);
        for (int i = 0; i < n; i++)
        {
            if (s[i] != '*')
            {
                continue;
            }
            for (int k = 1; k < n; k++)
            {
                if (s[i + k] == '*' && s[i + 2 * k] == '*' && s[i + 3 * k] == '*' && s[i + 4 * k] == '*')
                {
                    writer.WriteLine("YES");
                    reader.Close();
                    writer.Close();
                    return;
                }
            }
        }
        writer.WriteLine("NO");
        reader.Close();
        writer.Close();
    }
    #region Read / Write

    private static Queue<string> currentLineTokens = new Queue<string>();

    private static string[] ReadAndSplitLine()
    {
        return reader.ReadLine().Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
    }

    public static string ReadToken()
    {
        while (currentLineTokens.Count == 0)
            currentLineTokens = new Queue<string>(ReadAndSplitLine());
        return currentLineTokens.Dequeue();
    }

    public static int ReadInt()
    {
        return int.Parse(ReadToken());
    }

    public static long ReadLong()
    {
        return long.Parse(ReadToken());
    }

    public static double ReadDouble()
    {
        return double.Parse(ReadToken(), CultureInfo.InvariantCulture);
    }

    public static int[] ReadIntArray()
    {
        return ReadAndSplitLine().Select(int.Parse).ToArray();
    }

    public static long[] ReadLongArray()
    {
        return ReadAndSplitLine().Select(long.Parse).ToArray();
    }

    public static double[] ReadDoubleArray()
    {
        return ReadAndSplitLine().Select(s => double.Parse(s, CultureInfo.InvariantCulture)).ToArray();
    }
    public static int[][] ReadIntMatrix(int numberOfRows)
    {
        int[][] matrix = new int[numberOfRows][];
        for (int i = 0; i < numberOfRows; i++)
            matrix[i] = ReadIntArray();
        return matrix;
    }
    public static int[][] ReadAndTransposeIntMatrix(int numberOfRows)
    {
        int[][] matrix = ReadIntMatrix(numberOfRows);
        int[][] ret = new int[matrix[0].Length][];
        for (int i = 0; i < ret.Length; i++)
        {
            ret[i] = new int[numberOfRows];
            for (int j = 0; j < numberOfRows; j++)
                ret[i][j] = matrix[j][i];
        }
        return ret;
    }

    public static string[] ReadLines(int quantity)
    {
        string[] lines = new string[quantity];
        for (int i = 0; i < quantity; i++)
            lines[i] = reader.ReadLine().Trim();
        return lines;
    }
    public static void WriteArray<T>(IEnumerable<T> array)
    {
        writer.WriteLine(string.Join(" ", array));
    }

    public static void Write<T>(params T[] array)
    {
        WriteArray(array);
    }

    public static void WriteLines<T>(IEnumerable<T> array)
    {
        foreach (var a in array)
            writer.WriteLine(a);
    }
    private static int Next()
    {
        int c;
        int res = 0;
        do
        {
            c = reader.Read();
            if (c == -1)
                return res;
        } while (c != '-' && (c < '0' || c > '9'));
        int sign = 1;
        if (c == '-')
        {
            sign = -1;
            c = reader.Read();
        }
        res = c - '0';
        while (true)
        {
            c = reader.Read();
            if (c < '0' || c > '9')
                return res * sign;
            res *= 10;
            res += c - '0';
        }
    }
    #endregion
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;

namespace Codeforces
{
    class А
    {
        private static ThreadStart s_threadStart = new А().Go;
        private static bool s_time = false;
        private static double s_eps = 1e-16;

        private void Go()
        {
            int n = GetInt();
            string s = GetString();

            for (int i = 0; i < n; i++)
            {
                for (int j = i + 1; j < n; j++)
                {
                    int diff = j - i;
                    bool ok = true;
                    for (int k = 0; k < 5; k++)
                    {
                        int pos = i + k*diff;
                        if(pos >= n || s[pos]=='.')
                        {
                            ok = false;
                            break;
                        }
                    }

                    if (ok)
                    {
                        Wl("yes");
                        return;
                    }
                }
            }

            Wl("no");
        }

        #region Template

        public static void Main(string[] args)
        {
            System.Diagnostics.Stopwatch timer = new System.Diagnostics.Stopwatch();
            Thread main = new Thread(new ThreadStart(s_threadStart), 200 * 1024 * 1024);
            timer.Start();
            main.Start();
            main.Join();
            timer.Stop();
            if (s_time)
                Wl(timer.ElapsedMilliseconds);
        }

        private static IEnumerator<string> ioEnum;
        private static string GetString()
        {
            while (ioEnum == null || !ioEnum.MoveNext())
            {
                ioEnum = Console.ReadLine().Split().AsEnumerable().GetEnumerator();
            }

            return ioEnum.Current;
        }

        private static int GetInt()
        {
            return int.Parse(GetString(), CultureInfo.InvariantCulture);
        }

        private static long GetLong()
        {
            return long.Parse(GetString(), CultureInfo.InvariantCulture);
        }

        private static double GetDouble()
        {
            return double.Parse(GetString(), CultureInfo.InvariantCulture);
        }

        private static List<int> GetIntArr(int n)
        {
            List<int> ret = new List<int>(n);
            for (int i = 0; i < n; i++)
            {
                ret.Add(GetInt());
            }
            return ret;
        }

        private static void Wl<T>(T o)
        {
            if (o is double)
            {
                Wld((o as double?).Value, "");
            }
            else if (o is float)
            {
                Wld((o as float?).Value, "");
            }
            else
                Console.WriteLine(o.ToString());
        }

        private static void Wl<T>(IEnumerable<T> enumerable)
        {
            Wl(string.Join(" ", enumerable.Select(e => e.ToString()).ToArray()));
        }

        private static void Wld(double d, string format)
        {
            Wl(d.ToString(format, CultureInfo.InvariantCulture));
        }

        #endregion
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            string str = Console.ReadLine();
            int t = 1, ind = 0, j = 0;
            bool y = true;

            while (ind + (t * 4) < n && y)
            {
                if (str[j] == '*')
                {
                    ind = j;
                    for (int i = ind; ind + (t * 4) < n; )
                    {
                        if (str[i] == '*' && str[i + t] == '*' && str[i + (t * 2)] == '*'
                            && str[i + (t * 3)] == '*' && str[i + (t * 4)] == '*')
                        { Console.WriteLine("yes"); y = false; break; }
                        else
                        { t++; i = ind; }
                    }
                }
                t = 1;
                j++;
                if (j >= n)
                    break;
            }
            if (y)
                Console.WriteLine("no");
        }
    }
}

// Submitted by Stratholme @ Macau
using System;
using System.IO;
using System.Collections.Generic;
using CCF_XOI;

namespace CodeForces
{
	class CF526_ZeptoCodeRush2015_A
	{
		public void Solve(XOI xoi)
		{
			int N, i, j, d;
			bool ans = false;
			string s;

			N = xoi.ReadInt();
			s = xoi.ReadString();

			for (i = 0; i < N && !ans; i++)
			{
				if (s[i] == '*')
				{
					for (j = i + 1; j < N && !ans; j++)
					{
						if (s[j] == '*')
						{
							d = j - i;
							int cnt = 1;
							for (int k = j + d; k < N && cnt < 4; k += d)
							{
								if (s[k] == '*') cnt++;
								else break;
							}
							ans = (cnt == 4);
						}
					}
				}
			}

			xoi.o.WriteLine(ans ? "yes" : "no");
		}
	}

	class CodeForcesMain
	{
		static void Main(string[] args)
		{
			(new CF526_ZeptoCodeRush2015_A()).Solve(new XOI());
		}
	}
}

namespace CCF_XOI
{	// version 2014.06.20
	class XOI
	{
		protected StreamReader sr;
		public StreamWriter o;
		protected Queue<string> buf = new Queue<string>();
		public bool EOF = false;

		public XOI()
		{
			this.sr = new StreamReader(Console.OpenStandardInput());
			this.o = new StreamWriter(Console.OpenStandardOutput());
			this.o.AutoFlush = true;
		}

		public XOI(string in_path, string out_path)
		{
			this.sr = new StreamReader(in_path);
			this.o = new StreamWriter(out_path);
			this.o.AutoFlush = true;
		}

		public int ReadInt()
		{
			string s = this.GetNext();
			if (s == null) return -1;
			else return Int32.Parse(s);
		}

		public long ReadLong()
		{
			string s = this.GetNext();
			if (s == null) return -1;
			else return Int64.Parse(s);
		}

		public double ReadDouble()
		{
			string s = this.GetNext();
			if (s == null) return -1;
			else return Double.Parse(s, System.Globalization.CultureInfo.InvariantCulture);
		}

		public string ReadString()
		{
			string s = this.GetNext();
			return (s == null ? null : s);
		}

		public string ReadLine()
		{	// I will ignore current buffer and read a new line
			string s = "";
			while (s == "" && !this.EOF)
			{
				s = sr.ReadLine();
				this.EOF = (s == null);
			}
			return (this.EOF ? null : s);
		}

		protected string GetNext()
		{
			if (buf.Count == 0)
			{
				while (buf.Count == 0 && !this.EOF)
				{
					string s = sr.ReadLine();
					if (s == null)
						this.EOF = true;
					else
						foreach (string ss in s.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries))
							buf.Enqueue(ss);
				}
			}

			return (this.EOF ? null : buf.Dequeue());
		}
	}
}

using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.Net.Sockets;
using System.Xml;
using System.Diagnostics;
using System.Linq;
using System.Threading;

static class Program
{
    #region IO
    public delegate ReadDelegate<T> ReadDelegate<T>(out T value);
    public delegate bool ParserDelegate<T>(string word, out T item);

    public class Input : IDisposable
    {
        private static EventArgs DefaultEventArgs = new EventArgs();

        public TextReader TextReader { get; private set; }

        public event EventHandler OnEndOfStream;
        public event EventHandler OnParseError;
        public event EventHandler OnReadError;

        public bool CanRead { get; private set; }
        public bool ThrowExceptions { get; set; }

        string line = string.Empty;
        int pos = 0;

        static EventHandler emptyHandler;

        public Input(string path)
            : this(File.OpenRead(path))
        {
        }
        public Input(Stream s)
            : this(new StreamReader(s))
        {

        }
        public Input(TextReader tr)
        {
            TextReader = tr;

            if (emptyHandler == null)
                emptyHandler = (a, b) => { };

            OnEndOfStream = emptyHandler;
            OnParseError = emptyHandler;
            OnReadError = emptyHandler;

            CanRead = true;
        }

        public static implicit operator Input(Stream s)
        {
            return new Input(s);
        }
        public static implicit operator Input(TextReader tr)
        {
            return new Input(tr);
        }

        private bool ReadStream()
        {
            if (!CanRead) return false;
            if (pos < line.Length) return true;

            Clear();

            string s = TextReader.ReadLine();
            if (s == null)
            {
                CanRead = false;
                return false;
            }

            line = s;
            return true;
        }

        public ReadDelegate<T> r<T>(out T value)
        {
            value = ReadData<T>();
            return r;
        }

        public void SkipChar()
        {
            if (pos < line.Length) pos++;
            else
            {
                ReadStream();
            }
        }
        public void SkipChars(int length)
        {
            while (length > 0)
            {
                int dt = line.Length - pos;
                if (dt <= 0)
                {
                    length--;
                    if (!ReadStream()) return;
                }
                dt = Math.Min(length, dt);
                pos += dt;
                length -= dt;
            }
        }

        public void SkipWhiteSpace()
        {
            while (true)
            {
                for (; pos < line.Length; pos++)
                {
                    if (!char.IsWhiteSpace(line[pos])) return;
                }
                if (!ReadStream())
                {
                    OnEndOfStream(this, DefaultEventArgs);
                    return;
                }
            }
        }
        public bool CanReadData()
        {
            SkipWhiteSpace();
            return CanRead;
        }

        public T[] ReadArray<T>()
        {
            int length = ReadInt32();
            return ReadArray<T>(length);
        }
        public T[] ReadArray<T>(int length)
        {
            ParserDelegate<T> parser = Parser.GetPrimitiveParser<T>();
            return ReadArray<T>(length, parser);
        }
        public T[] ReadArray<T>(ParserDelegate<T> parser)
        {
            int length = ReadInt32();
            return ReadArray<T>(length, parser);
        }
        public T[] ReadArray<T>(int length, ParserDelegate<T> parser)
        {
            T[] res = new T[length];
            for (int i = 0; i < length; i++)
            {
                res[i] = ReadData<T>(parser);
            }
            return res;
        }

        public Decimal ReadDecimal()
        {
            return ReadData<Decimal>(Parser.DecimalParser);
        }
        public Double ReadDouble()
        {
            return ReadData<Double>(Parser.DoubleParser);
        }
        public Single ReadSingle()
        {
            return ReadData<Single>(Parser.SingleParser);
        }
        public UInt64 ReadUInt64()
        {
            return ReadData<UInt64>(UInt64.TryParse);
        }
        public UInt32 ReadUInt32()
        {
            return ReadData<UInt32>(UInt32.TryParse);
        }
        public UInt16 ReadUInt16()
        {
            return ReadData<UInt16>(UInt16.TryParse);
        }
        public Int64 ReadInt64()
        {
            return ReadData<Int64>(Int64.TryParse);
        }
        public Int32 ReadInt32()
        {
            return ReadData<Int32>(Int32.TryParse);
        }
        public Int16 ReadInt16()
        {
            return ReadData<Int16>(Int16.TryParse);
        }
        public Boolean ReadYesNo()
        {
            return ReadData<Boolean>(Parser.YesNoParser);
        }
        public Boolean ReadBoolean()
        {
            return ReadData<Boolean>(Boolean.TryParse);
        }
        public Byte ReadByte()
        {
            return ReadData<Byte>(Byte.TryParse);
        }

        private bool ReadCheck()
        {
            if (!CanRead)
            {
                OnReadError(this, DefaultEventArgs);
                if (ThrowExceptions)
                {
                    throw new Exception("!CanRead");
                }
                return false;
            }
            return true;
        }
        public T ReadData<T>()
        {
            return ReadData<T>(true);
        }
        public T ReadData<T>(bool skipWhiteSpace)
        {
            ParserDelegate<T> parser = Parser.GetPrimitiveParser<T>();
            return ReadData<T>(parser, skipWhiteSpace);
        }
        public T ReadData<T>(ParserDelegate<T> parser)
        {
            return ReadData<T>(parser, true);
        }
        public T ReadData<T>(ParserDelegate<T> parser, bool skipWhiteSpace)
        {
            if (skipWhiteSpace)
                SkipWhiteSpace();

            if (!ReadCheck()) return default(T);

            string s = ReadWord(false);

            T res;
            if (!parser.Invoke(s, out res))
            {
                OnParseError(this, DefaultEventArgs);
                if (ThrowExceptions)
                {
                    throw new Exception("!validate, word = " + Output.ToString(s, 256));
                }
            }
            return res;
        }

        public string ReadWord()
        {
            return ReadWord(true);
        }
        public string ReadWord(bool skipWhiteSpace)
        {
            if (skipWhiteSpace)
                SkipWhiteSpace();

            if (!ReadCheck()) return string.Empty;

            int from = pos;
            int to = pos;
            for (int i = pos; i < line.Length; i++)
            {
                if (char.IsWhiteSpace(line[i])) break;
                to = i + 1;
            }
            pos = to;

            return line.Substring(from, to - from);
        }

        public string ReadLine()
        {
            if (!ReadCheck()) return string.Empty;

            ReadStream();
            string res = line.Substring(pos);
            pos = line.Length;

            return res;
        }

        public void Close()
        {
            TextReader.Close();
        }
        public void Clear()
        {
            pos = 0;
            line = string.Empty;
        }

        private bool disposed = false;
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    line = string.Empty;
                    TextReader.Dispose();
                }
                disposed = true;
            }
        }
        ~Input()
        {
            Dispose(false);
        }
    }
    public class Output : IDisposable
    {
        static char[] space = new char[] { ' ' };

        public TextWriter TextWriter { get; private set; }
        public bool AutoFlush { get; set; }

        public static string ToString(object obj, int maxLength)
        {
            return ToString(FormatReal(obj), maxLength);
        }
        public static string ToString(string s, int maxLength)
        {
            if (s.Length <= maxLength) return s;
            else return s.Substring(0, maxLength) + "...";
        }
        public static object FormatReal(object v, string format)
        {
            if (v is decimal) return ((decimal)v).ToString(format).Replace(',', '.');
            if (v is double) return ((double)v).ToString(format).Replace(',', '.');
            if (v is float) return ((float)v).ToString(format).Replace(',', '.');

            return v;
        }
        public static object FormatReal(object v)
        {
            if (v is decimal || v is double || v is float)
            {
                return v.ToString().Replace(',', '.');
            }
            return v;
        }

        public Output()
            : this(new MemoryStream())
        {
        }
        public Output(string path)
            : this(File.Create(path))
        {

        }
        public Output(Stream s)
            : this(new StreamWriter(s))
        {
        }
        public Output(TextWriter tw)
        {
            TextWriter = tw;
        }

        public static implicit operator Output(Stream s)
        {
            return new Output(s);
        }

        public static implicit operator Output(TextWriter tw)
        {
            return new Output(tw);
        }

        public static Output operator +(Output output, object obj)
        {
            output.Write(obj);
            return output;
        }
        public Output WriteArray<T>(params T[] array)
        {
            return WriteArray<T>(array, false);
        }
        public Output WriteArray<T>(T[] array, bool appendLength)
        {
            return WriteArray<T>(array, 0, array.Length, appendLength);
        }
        public Output WriteArray<T>(T[] array, int index, int count)
        {
            return WriteArray<T>(array, index, count, false);
        }
        public Output WriteArray<T>(T[] array, int index, int count, bool appendLength)
        {
            if (index + count > array.Length)
            {
                string message = string.Format(
                    "Index out of range: {0} + {1} >= {2}",
                    index,
                    count,
                    array.Length);
                throw new Exception(message);
            }
            if (appendLength)
            {
                WriteLine(count);
            }
            for (int i = 0; i < count; i++)
            {
                Write(array[i + index]);
                Write(space, 0, space.Length);
            }
            WriteLine();

            return this;
        }
        public Output WriteLine(object obj)
        {
            obj = FormatReal(obj);
            return WriteLine(obj.ToString());
        }
        public Output WriteLine(string format, params object[] args)
        {
            return WriteLine(string.Format(format, args));
        }
        public Output WriteLine(string s)
        {
            return WriteLine(s.ToCharArray());
        }
        public Output WriteLine(char[] buffer)
        {
            return WriteLine(buffer, 0, buffer.Length);
        }
        public Output WriteLine(char[] buffer, int index, int count)
        {
            TextWriter.WriteLine(buffer, index, count);
            if (AutoFlush) TextWriter.Flush();
            return this;
        }
        public Output WriteLine()
        {
            TextWriter.WriteLine();
            if (AutoFlush) TextWriter.Flush();
            return this;
        }
        public Output Write(object obj)
        {
            obj = FormatReal(obj);
            return Write(obj.ToString());
        }
        public Output Write(string format, params object[] args)
        {
            return Write(string.Format(format, args));
        }
        public Output Write(string s)
        {
            return Write(s.ToCharArray());
        }
        public Output Write(char[] buffer)
        {
            return Write(buffer, 0, buffer.Length);
        }
        public Output Write(char[] buffer, int index, int count)
        {
            TextWriter.Write(buffer, index, count);
            if (AutoFlush) TextWriter.Flush();
            return this;
        }

        public void Close()
        {
            TextWriter.Close();
        }
        public void Flush()
        {
            TextWriter.Flush();
        }

        private bool disposed = false;
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    TextWriter.Dispose();
                }
                disposed = true;
            }
        }
        ~Output()
        {
            Dispose(false);
        }
    }
    public static class Parser
    {
        public static ParserDelegate<T> GetPrimitiveParser<T>()
        {
            if (!typeof(T).IsPrimitive && typeof(T) != typeof(String)) throw new Exception("Unknown type");
            else if (default(T) is Byte)     return new ParserDelegate<Byte>(Byte.TryParse) as ParserDelegate<T>;
            else if (default(T) is Boolean)  return new ParserDelegate<Boolean>(Boolean.TryParse) as ParserDelegate<T>;
            else if (default(T) is Int16)    return new ParserDelegate<Int16>(Int16.TryParse) as ParserDelegate<T>;
            else if (default(T) is Int32)    return new ParserDelegate<Int32>(Int32.TryParse) as ParserDelegate<T>;
            else if (default(T) is Int64)    return new ParserDelegate<Int64>(Int64.TryParse) as ParserDelegate<T>;
            else if (default(T) is UInt16)   return new ParserDelegate<UInt16>(UInt16.TryParse) as ParserDelegate<T>;
            else if (default(T) is UInt32)   return new ParserDelegate<UInt32>(UInt32.TryParse) as ParserDelegate<T>;
            else if (default(T) is UInt64)   return new ParserDelegate<UInt64>(UInt64.TryParse) as ParserDelegate<T>;
            else if (default(T) is Single)   return new ParserDelegate<Single>(Parser.SingleParser) as ParserDelegate<T>;
            else if (default(T) is Double)   return new ParserDelegate<Double>(Parser.DoubleParser) as ParserDelegate<T>;
            else if (default(T) is Decimal)  return new ParserDelegate<Decimal>(Parser.DecimalParser) as ParserDelegate<T>;
            else if (typeof(T) == typeof(String))   return new ParserDelegate<String>(Parser.StringParser) as ParserDelegate<T>;
            else throw new Exception("Unknown type");
        }
        public static bool YesNoParser(string s, out Boolean result)
        {
            s = s.ToLower();
            if (s == "yes") result = true;
            else if (s == "no") result = false;
            else
            {
                result = false;
                return false;
            }
            return true;
        }
        public static bool ReplaceDot;
        public static bool StringParser(string s, out string result)
        {
            result = s;
            return string.IsNullOrEmpty(s);
        }
        private static string fs(string s)
        {
            if (ReplaceDot) return s.Replace(',', '.');
            else return s;
        }
        public static bool DecimalParser(string s, out Decimal result)
        {
            return Decimal.TryParse(fs(s), out result);
        }
        public static bool DoubleParser(string s, out Double result)
        {
            return Double.TryParse(fs(s), out result);
        }
        public static bool SingleParser(string s, out Single result)
        {
            return Single.TryParse(fs(s), out result);
        }
    }
    #endregion
    #region Streams
    static string endl = Environment.NewLine;
    static Input cin = new Input(Console.In);
    static Output cout = new Output(Console.Out);
    static Output cerr = new Output(Console.Error);
    static StringBuilder sb = new StringBuilder();
    #endregion
    #region Time
    //*
    static Stopwatch sw = new Stopwatch();
    static void Start()
    {
        sw.Reset();
        sw.Start();
    }
    static void Restart(string text = "")
    {
        Stop(text);
        Start();
    }
    static void Time(string text = "")
    {
        if (string.IsNullOrEmpty(text))
        {
            cerr.WriteLine(sw.Elapsed);
        }
        else
        {
            cerr.WriteLine(text + ": " + sw.Elapsed);
        }
    }
    static void Stop(string text = "")
    {
        sw.Stop();
        Time(text);
    }
    //*/
    #endregion

    static void InitIO(string name)
    {
#if DEBUG
#else
        cin = new Input(name + ".in");
        cout = new Output(name + ".out");
        Parser.ReplaceDot = false;
#endif
    }

    static void Main()
    {
        var n = cin.ReadInt32();
        var s = cin.ReadLine();

        bool res = false;
        for(var i = 0; i < n && !res; i++)
        {
            if (s[i] == '.') continue;
            for(var j = 1; j < n && !res; j++)
            {
                bool r = true;
                for(var t = 1; t <= 4; t++)
                {
                    var x = i + t * j;
                    if (x >= n || s[x] != '*')
                    {
                        r = false;
                        break;
                    }
                }
                res |= r;
            }
        }

        cout.WriteLine(res ? "yes" : "no");
    }
}

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

namespace codeforces
{
	class Program
	{
		public const int Osn = 1000000007;

		public class Pair
		{
			public long First;

			public int Second;

			public int Third;
		}

		public class PairComparer : IComparer<Pair>
		{
			public int Compare(Pair x, Pair y)
			{
				if (x.First > y.First || (x.First == y.First && x.Second < y.Second))
					return -1;
				return 1;
			}
		}

		public static long GetGcd(long a, long b)
		{
			while (true)
			{
				if (b == 0)
					return a;
				var a1 = a;
				a = b;
				b = a1 % b;
			}
		}

		public static void WriteYesNo(bool x, string yes = "YES", string no = "NO")
		{
			if (x)
				Console.WriteLine(yes);
			else
			{
				Console.WriteLine(no);
			}
		}

		public static string ReadString()
		{
			return Console.ReadLine();
		}

		public static List<int> ReadListOfInts()
		{
			var s = Console.ReadLine();
			return s.Split(' ').Select(int.Parse).ToList();
		}

		public static List<long> ReadListOfLongs()
		{
			var s = Console.ReadLine();
			return s.Split(' ').Select(long.Parse).ToList();
		}

		public static int ReadInt()
		{
			var s = Console.ReadLine();
			return int.Parse(s);
		}

		public static long ReadLong()
		{
			var s = Console.ReadLine();
			return long.Parse(s);
		}

		public class Vertex
		{
			public int Was;

			public List<Pair> Edges;
		}

		public static List<List<Vertex>> Graph = new List<List<Vertex>>();

/*		public static bool Dfs(int x, int y, int prevx, int prevy)
		{
			Graph[x][y].Was = 1;
			var result = false;
			foreach (var t in Graph[x][y].Edges)
			{
				if (Graph[t.First][t.Second].Was == 0)
					result |= Dfs(t.First, t.Second, x, y);
				else if (t.First != prevx || t.Second != prevy)
					return true;
			}

			return result;
		}*/

		public static bool IsPrime(int x)
		{
			for (var j = 2; j * j <= x; ++j)
				if (x % j == 0)
					return false;
			return true;
		}

		public class LinkedVertex
		{
			public int Next;

			public int Prev;

			public int Value;
		}

		private static void Main()
		{
			var n = ReadInt();
			var s = ReadString();
			var good = false;
			for (var j = 1; j <= n; ++j)
			{
				for (var i = 0; i < n; ++i)
				{
					if (s[i] == '*' && (i + j < n && s[i + j] == '*') && (i + 2 * j < n && s[i + 2 * j] == '*') &&
					    (i + 3 * j < n && s[i + 3 * j] == '*') && (i + 4 * j < n && s[i + 4 * j] == '*'))
						good = true;
				}
			}
			WriteYesNo(good, "yes", "no");
			Console.ReadLine();
		}
	}
}

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

namespace zepto_A
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            char[] lvl_char = Console.ReadLine().ToCharArray();
            int[] lvl = new int[lvl_char.Length];
            for(int i = 0; i<lvl_char.Length;i++)
            {
                lvl[i] = (int)lvl_char[i];
            }
            int kmax = (int)(n - 5) / 4;
            int temp;
            int star = (int)'*';
            int good = star * star * star * star * star;
            bool fl = true;
            for (int k = 0; k <= kmax && fl; k++)
            {
                for (int i = 0; i <= n - 5 - 4 * k; i++)
                {
                    temp = lvl[i]*lvl[i+1+k]*lvl[i+2+2*k]*lvl[i+3+3*k]*lvl[i+4+4*k];
                    if (temp == good)
                    {
                        Console.WriteLine("yes");
                        fl = false;
                        break;
                    }
                }
            }
            if (fl) {
                Console.WriteLine("no");
            }
            Console.ReadLine();
        }
    }
}

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

namespace ConsoleApplication1
{
    class Program
    {
        static int N,pos,cnt;
        static string board;

        static void Main(string[] args)
        {
            N = Convert.ToInt32(Console.ReadLine());
            board = Console.ReadLine();

            for (int i = 0; i < board.Length; ++i)
                for (int j = 1; j <= board.Length; ++j)
                {
                    pos = i;
                    cnt = 0;
                    while (pos < board.Length && board[pos] == '*')
                    {
                        ++cnt;
                        pos += j;
                    }

                    if (cnt == 5)
                    {
                        Console.WriteLine("yes");
                        return;
                    }

                }

            Console.WriteLine("no");

        }

    }

}

using System;

namespace Question1
{
    partial class Question1
    {
        static void Main(string[] args)
        {
            int n;
            string level;
            bool answer = false;

            n = NextInt();
            level = ReadLine();

            answer = FindAnswer(level);

            if (answer)
                Console.WriteLine("yes");
            else
                Console.WriteLine("no");
        }

        private static bool FindAnswer(string level)
        {
            int count = 0;

            for (int i = 0; i < level.Length; i++)
            {
                if (level[i].Equals('*'))
                {
                    for (int j = 1; i + j < level.Length; j++)
                    {
                        count = 0;

                        for (int k = i + j; k < level.Length; k+=j)
                        {
                            if (level[i] == level[k])
                                count++;
                            else
                                break;

                            if (count == 4)
                                return true;
                        }
                    }
                }
            }

            return false;
        }
    }

    partial class Question1
    {
        static string[] tokens = new string[0];
        static int cur_token = 0;

        static void ReadArray(char sep)
        {
            cur_token = 0;
            tokens = Console.ReadLine().Split(sep);
        }

        static int ReadInt()
        {
            return int.Parse(Console.ReadLine());
        }

        static long ReadLong()
        {
            return long.Parse(Console.ReadLine());
        }

        static int NextInt()
        {
            if (cur_token == tokens.Length)
                ReadArray(' ');
            return int.Parse(tokens[cur_token++]);
        }

        static long NextLong()
        {
            if (cur_token == tokens.Length)
                ReadArray(' ');
            return long.Parse(tokens[cur_token++]);
        }

        static double NextDouble()
        {
            if (cur_token == tokens.Length)
                ReadArray(' ');
            return double.Parse(tokens[cur_token++]);
        }

        static decimal NextDecimal()
        {
            if (cur_token == tokens.Length)
                ReadArray(' ');
            return decimal.Parse(tokens[cur_token++]);
        }

        static string NextToken()
        {
            if (cur_token == tokens.Length)
                ReadArray(' ');
            return tokens[cur_token++];
        }

        static string ReadLine()
        {
            return Console.ReadLine();
        }
    }
}

using System;
using System.IO;
using System.Linq;

namespace Codeforces
{
	internal class Template
	{
		private static readonly Scanner cin = new Scanner();

		private static void Main()
		{
#if !ONLINE_JUDGE
			Console.SetIn(new StreamReader(@"C:\CodeForces\input.txt"));
#endif
			new Template().Solve();
			Console.ReadLine();
		}

		private void Solve()
		{
			var len = cin.NextInt();
			var str = cin.NextString();
			for (var i = 0; i < str.Length; i++)
			{
				for (var j = 1; j < str.Length; j++)
				{
					var cnt = 0;
					for (var k = 0; k < 5; k++)
					{
						var idx = i + j*k;
						if (idx < str.Length)
						{
							if (str[idx] == '*')
							{
								cnt++;
							}
						}
					}
					if (cnt == 5)
					{
						Console.WriteLine("yes");
						return;
					}
				}
			}
			Console.WriteLine("no");
		}
	}

	internal class Scanner
	{
		private string[] s = new string[0];
		private int i;
		private readonly char[] cs = { ' ' };

		public string NextString()
		{
			if (i < s.Length) return s[i++];
			var line = Console.ReadLine() ?? string.Empty;
			s = line.Split(cs, StringSplitOptions.RemoveEmptyEntries);
			i = 1;
			return s.First();
		}

		public double NextDouble()
		{
			return double.Parse(NextString());
		}

		public int NextInt()
		{
			return int.Parse(NextString());
		}

		public long NextLong()
		{
			return long.Parse(NextString());
		}
	}
}

using System;
using System.Linq;
using System.Text.RegularExpressions;
using System.Collections.Generic;
using Debug = System.Diagnostics.Debug;
using StringBuilder = System.Text.StringBuilder;
using System.Numerics;
namespace Program
{
    public class Solver
    {

        public void Solve()
        {
            var n = sc.Integer();
            var s = sc.Scan();
            for (int k = 0; k < n; k++)
            {
                for (int l = 1; l < n; l++)
                {
                    if (k + 4 * l >= n)
                        break;
                    var f = true;
                    for (int i = 0; i < 5; i++)
                        if (s[k + i * l] == '.') f = false;
                    if (f)
                    {
                        IO.Printer.Out.WriteLine("yes");
                        return;
                    }

                }
            }
            IO.Printer.Out.WriteLine("no");
        }
        public IO.StreamScanner sc = new IO.StreamScanner(Console.OpenStandardInput());
        static T[] Enumerate<T>(int n, Func<int, T> f) { var a = new T[n]; for (int i = 0; i < n; ++i) a[i] = f(i); return a; }

    }
}

#region Ex
namespace Program.IO
{
    using System.IO;
    using System.Text;
    using System.Globalization;
    public class Printer : StreamWriter
    {
        static Printer() { Out = new Printer(Console.OpenStandardOutput()) { AutoFlush = false }; }
        public static Printer Out { get; set; }
        public override IFormatProvider FormatProvider { get { return CultureInfo.InvariantCulture; } }
        public Printer(System.IO.Stream stream) : base(stream, new UTF8Encoding(false, true)) { }
        public Printer(System.IO.Stream stream, Encoding encoding) : base(stream, encoding) { }
        public void Write<T>(string format, IEnumerable<T> source) { base.Write(format, source.OfType<object>().ToArray()); }
        public void WriteLine<T>(string format, IEnumerable<T> source) { base.WriteLine(format, source.OfType<object>().ToArray()); }
    }
    public class StreamScanner
    {
        public StreamScanner(Stream stream) { str = stream; }
        public readonly Stream str;
        private readonly byte[] buf = new byte[1024];
        private int len, ptr;
        public bool isEof = false;
        public bool IsEndOfStream { get { return isEof; } }
        private byte read()
        {
            if (isEof) return 0;
            if (ptr >= len) { ptr = 0; if ((len = str.Read(buf, 0, 1024)) <= 0) { isEof = true; return 0; } }
            return buf[ptr++];
        }
        public char Char() { byte b = 0; do b = read(); while (b < 33 || 126 < b); return (char)b; }

        public string Scan()
        {
            var sb = new StringBuilder();
            for (var b = Char(); b >= 33 && b <= 126; b = (char)read())
                sb.Append(b);
            return sb.ToString();
        }
        public long Long()
        {
            if (isEof) return long.MinValue;
            long ret = 0; byte b = 0; var ng = false;
            do b = read();
            while (b != '-' && (b < '0' || '9' < b));
            if (b == '-') { ng = true; b = read(); }
            for (; true; b = read())
            {
                if (b < '0' || '9' < b)
                    return ng ? -ret : ret;
                else ret = ret * 10 + b - '0';
            }
        }
        public int Integer() { return (isEof) ? int.MinValue : (int)Long(); }
        public double Double() { return double.Parse(Scan(), CultureInfo.InvariantCulture); }
        private T[] enumerate<T>(int n, Func<T> f)
        {
            var a = new T[n];
            for (int i = 0; i < n; ++i) a[i] = f();
            return a;
        }

        public char[] Char(int n) { return enumerate(n, Char); }
        public string[] Scan(int n) { return enumerate(n, Scan); }
        public double[] Double(int n) { return enumerate(n, Double); }
        public int[] Integer(int n) { return enumerate(n, Integer); }
        public long[] Long(int n) { return enumerate(n, Long); }
    }
}
static class Ex
{
    static public string AsString(this IEnumerable<char> ie) { return new string(System.Linq.Enumerable.ToArray(ie)); }
    static public string AsJoinedString<T>(this IEnumerable<T> ie, string st = " ") { return string.Join(st, ie); }
    static public void Main()
    {
        var solver = new Program.Solver();
        solver.Solve();
        Program.IO.Printer.Out.Flush();
    }
}
#endregion

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

namespace TaskA
{
    class Program
    {
        static void Main()
        {
            List<char> inputs = Console.In.ReadToEnd().Split(new[] { ' ', '\n', '\r', '\t' }, StringSplitOptions.RemoveEmptyEntries).ToArray().Skip(1).ToList()[0].ToCharArray().ToList();
            string answer = CheckLevel(inputs);
            Console.WriteLine(answer);
        }

        static string CheckLevel(List<char> areas)
        {
            List<int> goodAreas = new List<int>();

            for (int i = 0; i < areas.Count; i++)
            {
                if (areas[i] == '*')
                {
                    goodAreas.Add(i);
                }
            }

            for (int i = 0; i < goodAreas.Count; i++)
            {
                for (int j = i + 1; j < goodAreas.Count; j++)
                {
                    int diff = goodAreas[j] - goodAreas[i];
                    int kGood = 1;
                    int p = j;
                    for (int k = j + 1; k < goodAreas.Count; k++)
                    {
                        int newDiff = goodAreas[k] - goodAreas[p];
                        if (newDiff < diff)
                        {
                            continue;
                        }
                        if (newDiff > diff)
                        {
                            break;
                        }
                        kGood++;
                        if (kGood == 4)
                        {
                            return "YES";
                        }
                        p = k;
                    }
                }
            }

            return "NO";
        }
    }
}

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

namespace KingOfThieves
{
	internal class Program
	{
		private static void Main(string[] args)
		{
			var input = args.Length == 0 ? new Input() : new Input(args[0]);

			var n = int.Parse(input.ReadLine());
			var items = new List<bool>(n);
			items.AddRange(input.ReadLine().Select(c => c == '*'));

			for (var i = 0; i < n - 4; i++)
			{
				if (items[i])
				{
					for (var j = i + 4; j < n; j += 4)
					{
						if (items[j])
						{
							var step = (j - i)/4;
							if (items[i + step] && items[j - step] && items[i + 2*step])
							{
								Console.WriteLine("yes");
								return;
							}
						}
					}
				}
			}
			Console.WriteLine("no");
		}

		private class Input
		{
			private readonly StreamReader _reader;

			public Input()
			{
			}

			public Input(string fileName)
			{
				_reader = new StreamReader(fileName);
			}

			public string ReadLine()
			{
				var line = _reader == null ? Console.ReadLine() : _reader.ReadLine();
				Console.Error.WriteLine(line);
				return line;
			}
		}
	}
}

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

namespace Problem_A
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            string level = Console.ReadLine();
            bool check = false;
            for (int i = 1; i <= n/4; i++)
            {
                for (int j = 0; j < n-(i*4); j++)
                {
                    if (level[j]=='.')
                    {
                        continue;
                    }
                    check = true;
                    int index = j;
                    for (int k = 0; k < 4; k++)
                    {
                        index += i;
                        if (level[index]=='.')
                        {
                            check = false;
                            break;
                        }
                    }
                    if (check)
                    {
                        break;
                    }
                }
                if (check)
                {
                    Console.WriteLine("yes");
                    break;
                }
            }
            if (!check)
            {
                Console.WriteLine("no");
            }
        }
    }
}

using System;
using System.IO;
using System.Text;

namespace King_of_Thieves
{
    internal class Program
    {
        private static readonly StreamReader reader = new StreamReader(Console.OpenStandardInput(1024*10), Encoding.ASCII, false, 1024*10);
        private static readonly StreamWriter writer = new StreamWriter(Console.OpenStandardOutput(1024*10), Encoding.ASCII, 1024*10);

        private static void Main(string[] args)
        {
            reader.ReadLine();
            string s = reader.ReadLine();

            bool ok = false;
            for (int i = 0; !ok && i < s.Length; i++)
            {
                if (s[i] == '*')
                {
                    for (int j = (s.Length - i - 1)/4; j > 0; j--)
                    {
                        bool f = true;
                        for (int k = 1; k <= 4; k++)
                        {
                            if (s[i+k*j]!='*')
                            {
                                f = false;
                                break;
                            }
                        }
                        if(f)
                        {
                            ok = true;
                            break;
                        }
                    }
                }
            }

            writer.WriteLine("{0}", ok ? "yes" : "no");
            writer.Flush();
        }
    }
}

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

namespace _526A
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            string input = Console.ReadLine();
            bool[] a = new bool[n];
            for (int i = 0; i < n; i++) a[i] = input[i] == '*';

            bool result = false;
            for (int i = 0; i < n - 4 && !result; i++)
            {
                for (int step = 1; step < (int)Math.Ceiling(n / 4D); step++)
                {
                    int jumps = 0;
                    while (jumps <= 4)
                    {
                        if (i + jumps * step >= n || !a[i + jumps * step])
                            break;
                        else
                            jumps++;
                    }

                    if (jumps == 5)
                    {
                        result = true;
                        break;
                    }
                }
            }

            Console.WriteLine(result ? "yes" : "no");
            //Console.ReadLine();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace zepto
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());

            string s = Console.ReadLine();
            int e = 0;
            string ans = "no";
            int[] ss = new int[10000];
            for (int i = 0, ind = 0; i < n - 1; i++)
            {
                if (s[i] == '*')
                    for (int j = i + 1; j < n; j++)
                    {
                        if (s[j] == '*') { ss[ind] = j - i; ind++; }
                    }

            }

            for (int i = 0; i < ss.Length - 1; i++)
            {
                if (ss[i] != 0)
                    for (int j = i + 1; j < ss.Length && ss[j] != 0; j++)
                    {
                        if (ss[i] == ss[j]) e++;
                    }
                if (e + 1 >= 4) { ans = "yes"; break; }
                else e = 0;
            }

            Console.WriteLine(ans);
        }
    }
}

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

namespace prA {

    class Program {
#if ONLINE_JUDGE
        private static readonly StreamReader reader = new StreamReader(Console.OpenStandardInput(1024 * 10), System.Text.Encoding.ASCII, false, 1024 * 10);
        private static readonly StreamWriter writer = new StreamWriter(Console.OpenStandardOutput(1024 * 10), System.Text.Encoding.ASCII, 1024 * 10);
#else
        private static readonly StreamWriter writer = new StreamWriter("output");
        private static readonly StreamReader reader = new StreamReader("input");
#endif
        static void Main(string[] args) {
            int n = Next();
            reader.ReadLine();
            string s = reader.ReadLine();
            int[] how = new int[101];
            List<int> pl = new List<int>();
            for(int i = 0; i < s.Length; i++) {
                char c = s[i];
                if(c == '.')
                    continue;
                foreach(int i1 in pl) {
                    how[i - i1]++;
                }
                pl.Add(i);
            }
            bool ans = false;
            foreach(int i in how) {
                ans = ans || i >= 4;
            }
            writer.Write(ans ? "yes" : "no");
            writer.Flush();
#if !ONLINE_JUDGE
            writer.Close();
#endif
        }
        private static int Next() {
            int c;
            int res = 0;
            do {
                c = reader.Read();
                if(c == -1)
                    return res;
            } while(c != '-' && (c < '0' || c > '9'));
            int sign = 1;
            if(c == '-') {
                sign = -1;
                c = reader.Read();
            }
            res = c - '0';
            while(true) {
                c = reader.Read();
                if(c < '0' || c > '9')
                    return res * sign;
                res *= 10;
                res += c - '0';
            }
        }
    }
}

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

// (づ°ω°)づﾐ★゜・。。・゜゜・。。・゜☆゜・。。・゜゜・。。・゜
public class Solver
{
    public void Solve()
    {
        int n = ReadInt();
        string s = ReadToken();
        for (int i = 1; i * 4 < n; i++)
            for (int j = 0; j + 4 * i < n; j++)
            {
                bool f = true;
                for (int k = 0; k < 4; k++)
                    if (s[j + k * i] == '.')
                        f = false;
                if (f)
                {
                    Write("yes");
                    return;
                }
            }
        Write("no");
    }

    #region Main

    protected static TextReader reader;
    protected static TextWriter writer;
    static void Main()
    {
#if DEBUG
        reader = new StreamReader("..\\..\\input.txt");
        writer = Console.Out;
        //writer = new StreamWriter("..\\..\\output.txt");
#else
        reader = new StreamReader(Console.OpenStandardInput());
        writer = new StreamWriter(Console.OpenStandardOutput());
        //reader = new StreamReader("cycle.in");
        //writer = new StreamWriter("cycle.out");
#endif
        try
        {
//            var thread = new Thread(new Solver().Solve, 1024 * 1024 * 128);
//            thread.Start();
//            thread.Join();
            new Solver().Solve();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
#if DEBUG
#else
            throw;
#endif
        }
        reader.Close();
        writer.Close();
    }

    #endregion

    #region Read / Write
    private static Queue<string> currentLineTokens = new Queue<string>();
    private static string[] ReadAndSplitLine() {return reader.ReadLine().Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);}
    public static string ReadToken(){while (currentLineTokens.Count == 0)currentLineTokens = new Queue<string>(ReadAndSplitLine());return currentLineTokens.Dequeue();}
    public static int ReadInt(){return int.Parse(ReadToken());}
    public static long ReadLong(){return long.Parse(ReadToken());}
    public static double ReadDouble(){return double.Parse(ReadToken(), CultureInfo.InvariantCulture);}
    public static int[] ReadIntArray(){return ReadAndSplitLine().Select(int.Parse).ToArray();}
    public static long[] ReadLongArray(){return ReadAndSplitLine().Select(long.Parse).ToArray();}
    public static double[] ReadDoubleArray(){return ReadAndSplitLine().Select(s => double.Parse(s, CultureInfo.InvariantCulture)).ToArray();}
    public static int[][] ReadIntMatrix(int numberOfRows){int[][] matrix = new int[numberOfRows][];for (int i = 0; i < numberOfRows; i++)matrix[i] = ReadIntArray();return matrix;}
    public static int[][] ReadAndTransposeIntMatrix(int numberOfRows){int[][] matrix = ReadIntMatrix(numberOfRows);int[][] ret = new int[matrix[0].Length][];
        for (int i = 0; i < ret.Length; i++){ret[i] = new int[numberOfRows];for (int j = 0; j < numberOfRows; j++)ret[i][j] = matrix[j][i];}return ret;}
    public static string[] ReadLines(int quantity){string[] lines = new string[quantity];for (int i = 0; i < quantity; i++)lines[i] = reader.ReadLine().Trim();return lines;}
    public static void WriteArray<T>(IEnumerable<T> array){writer.WriteLine(string.Join(" ", array));}
    public static void Write(params object[] array){WriteArray(array);}
    public static void WriteLines<T>(IEnumerable<T> array){foreach (var a in array)writer.WriteLine(a);}
    private class SDictionary<TKey, TValue> : Dictionary<TKey, TValue>{public new TValue this[TKey key]{
        get { return ContainsKey(key) ? base[key] : default(TValue); }set { base[key] = value; }}}
    private static T[] Init<T>(int size) where T : new(){var ret = new T[size];for (int i = 0; i < size; i++)ret[i] = new T();return ret;}
    #endregion
}

using System;
using System.Collections.Generic;

namespace A526{
	class Program{
		static void Main(string[] args){
            int n = int.Parse(Console.ReadLine());
            string level = Console.ReadLine();
            int currentLength = 1;

            while (currentLength * 3 < level.Length)
            {
                for(int i = 0; i < level.Length; i++)
                {
                    try
                    {
                        if (level[i + currentLength * 0] == '*'
                            && level[i + currentLength * 1] == '*'
                            && level[i + currentLength * 2] == '*'
                            && level[i + currentLength * 3] == '*')
                        {
                            Console.WriteLine("yes");
                            return;
                        }
                    } catch
                    {
                        break;
                    }
                }
                currentLength++;
            }
            Console.WriteLine("no");
		}
	}
}

using System;
using System.Text;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;

namespace WarmingUpC_Sharp
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = ReadInt();
            string level = Console.ReadLine();
            int pos = PosFirstPlatform(level), jumps = 0, count = 0;
            if (pos < 0)
            {
                Console.WriteLine("no");
                return;
            }
            for (int i = pos; i < n; i++)
            {
                if (level[i] == '.')
                    continue;
                if ((n - pos) / 5 < 1)
                {
                    Console.WriteLine("no");
                    return;
                }
                else
                    jumps++;
                for (int j = i; j < n; j+=jumps)
                {
                    if (level[j] == '*')
                        count++;
                    else
                    {
                        count = 0;
                        break;
                    }
                }
                if (count >= 5)
                {
                    Console.WriteLine("yes");
                    return;
                }
            }
            Console.WriteLine("no");
        }
        public static int PosFirstPlatform(string elem)
        {
            for (int i = 0; i < elem.Length; i++)
            {
                if (elem[i] == '*')
                    return i;
            }
            return -1;
        }
        public static void Swap<T>(ref T a, ref T b)
        {
            T t = a;
            a = b;
            b = t;
        }
        public static int ReadInt()
        {
            return int.Parse(Console.ReadLine());
        }
        public static long ReadLong()
        {
            return long.Parse(Console.ReadLine());
        }
        public static int[] ReadListIntegers()
        {
            return Array.ConvertAll<string, int>(Console.ReadLine().Split(' '), int.Parse);
        }
        public static long[] ReadListLongs()
        {
            return Array.ConvertAll<string, long>(Console.ReadLine().Split(' '), long.Parse);
        }
        public static string[] ReadArrayStrings()
        {
            return Console.ReadLine().Split(' ');
        }
    }
}

using System;
using System.Text;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;

namespace WarmingUpC_Sharp
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = ReadInt();
            string level = Console.ReadLine();
            int pos = PosFirstPlatform(level), jumps = 0, count = 0;
            if (pos < 0)
            {
                Console.WriteLine("no");
                return;
            }
            for (int i = pos; i < n; i++)
            {
                if (level[i] == '.')
                    continue;
                jumps = 0;
                while (jumps < n - i)
                {
                    jumps++;
                    for (int j = i; j < n; j += jumps)
                    {
                        if (level[j] == '*')
                            count++;
                        else
                        {
                            count = 0;
                            break;
                        }
                    }
                    if (count >= 5)
                    {
                        Console.WriteLine("yes");
                        return;
                    }
                    count = 0;
                }
            }
            Console.WriteLine("no");
        }
        public static int PosFirstPlatform(string elem)
        {
            for (int i = 0; i < elem.Length; i++)
            {
                if (elem[i] == '*')
                    return i;
            }
            return -1;
        }
        public static void Swap<T>(ref T a, ref T b)
        {
            T t = a;
            a = b;
            b = t;
        }
        public static int ReadInt()
        {
            return int.Parse(Console.ReadLine());
        }
        public static long ReadLong()
        {
            return long.Parse(Console.ReadLine());
        }
        public static int[] ReadListIntegers()
        {
            return Array.ConvertAll<string, int>(Console.ReadLine().Split(' '), int.Parse);
        }
        public static long[] ReadListLongs()
        {
            return Array.ConvertAll<string, long>(Console.ReadLine().Split(' '), long.Parse);
        }
        public static string[] ReadArrayStrings()
        {
            return Console.ReadLine().Split(' ');
        }
    }
}

// Submitted by Stratholme @ Macau
using System;
using System.IO;
using System.Collections.Generic;
using CCF_XOI;

namespace CodeForces
{
	class CF526_ZeptoCodeRush2015_A
	{
		public void Solve(XOI xoi)
		{
			int N, i, j, d;
			bool ans = false;
			string s;

			N = xoi.ReadInt();
			s = xoi.ReadString();

			for (i = 0; i < N && !ans; i++ )
			{
				if (s[i] == '*')
				{
					for (j = i + 1; j < N && !ans; j++)
					{
						if (s[j] == '*')
						{
							d = j - i;
							int cnt = 2;
							for (int k = j + d; k < N && cnt < 4; k += d)
							{
								if (s[k] == '*') cnt++;
								else break;
							}
							ans = (cnt == 4);
						}
					}
				}
			}

			xoi.o.WriteLine(ans ? "yes" : "no");
		}
	}

	class CodeForcesMain
	{
		static void Main(string[] args)
		{
			(new CF526_ZeptoCodeRush2015_A()).Solve(new XOI());
		}
	}
}

namespace CCF_XOI
{	// version 2014.06.20
	class XOI
	{
		protected StreamReader sr;
		public StreamWriter o;
		protected Queue<string> buf = new Queue<string>();
		public bool EOF = false;

		public XOI()
		{
			this.sr = new StreamReader(Console.OpenStandardInput());
			this.o = new StreamWriter(Console.OpenStandardOutput());
			this.o.AutoFlush = true;
		}

		public XOI(string in_path, string out_path)
		{
			this.sr = new StreamReader(in_path);
			this.o = new StreamWriter(out_path);
			this.o.AutoFlush = true;
		}

		public int ReadInt()
		{
			string s = this.GetNext();
			if (s == null) return -1;
			else return Int32.Parse(s);
		}

		public long ReadLong()
		{
			string s = this.GetNext();
			if (s == null) return -1;
			else return Int64.Parse(s);
		}

		public double ReadDouble()
		{
			string s = this.GetNext();
			if (s == null) return -1;
			else return Double.Parse(s, System.Globalization.CultureInfo.InvariantCulture);
		}

		public string ReadString()
		{
			string s = this.GetNext();
			return (s == null ? null : s);
		}

		public string ReadLine()
		{	// I will ignore current buffer and read a new line
			string s = "";
			while (s == "" && !this.EOF)
			{
				s = sr.ReadLine();
				this.EOF = (s == null);
			}
			return (this.EOF ? null : s);
		}

		protected string GetNext()
		{
			if (buf.Count == 0)
			{
				while (buf.Count == 0 && !this.EOF)
				{
					string s = sr.ReadLine();
					if (s == null)
						this.EOF = true;
					else
						foreach (string ss in s.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries))
							buf.Enqueue(ss);
				}
			}

			return (this.EOF ? null : buf.Dequeue());
		}
	}
}

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

namespace zepto_A
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            char[] lvl_char = Console.ReadLine().ToCharArray();
            int[] lvl = new int[lvl_char.Length];
            for(int i = 0; i<lvl_char.Length;i++)
            {
                lvl[i] = (int)lvl_char[i];
            }
            int kmax = (int)(n - 5) / 4;
            int temp;
            int star = (int)'*';
            int good = star * star * star * star * star;
            bool fl = true;
            for (int k = 1; k <= kmax && fl; k++)
            {
                for (int i = 0; i <= n - 5 - 4 * k; i++)
                {
                    temp = lvl[i]*lvl[i+1+k]*lvl[i+2+2*k]*lvl[i+3+3*k]*lvl[i+4+4*k];
                    if (temp == good)
                    {
                        Console.WriteLine("yes");
                        fl = false;
                        break;
                    }
                }
            }
            if (fl) {
                Console.WriteLine("no");
            }
            Console.ReadLine();
        }
    }
}

using System;
using System.Linq;

namespace CSharp
{
    class _526A
    {
        public static void Main()
        {
            int n = int.Parse(Console.ReadLine());
            string s = Console.ReadLine();

            Console.WriteLine(Enumerable.Range(1, n).Any(d => Enumerable.Range(0, d).Any(r => string.Concat(Enumerable.Range(0, n).Where(i => i % d == r).Select(i => s[i])).Contains("****"))) ? "yes" : "no");
        }
    }
}

using System;

public class KingOfThieves
{

	static public void Print(int n,int s,int k,int d)
	{
		string markers="";
		for(int i=0;i<s;++i)markers+=".";
		for(int k2=0;k2<=3;++k2)
			{
			if(k2==k)	markers+="|";
			else		markers+="-";
			for(int i=1;i<d && s+k2*d+i<n;++i)markers+=".";
			}
		for(int i=d;s+3*d+i<n;++i)markers+=".";
		Console.WriteLine(markers);
	}

	static public void Main()
	{
		int n=Convert.ToInt32(Console.ReadLine());
		if(n<1 || n>100){Console.WriteLine("no"); return;}
		string input=Console.ReadLine();

		if(n!=input.Length){Console.WriteLine("no"); return;}

		for(int d=n/3;d>=1;--d)
		{
			for(int s=0;s<n-3*d;++s)
			{
				bool pit=false;

				for(int k=0;k<=3;++k)
				{

			//		Console.WriteLine(input);
			//		Print(n,s,k,d);

					if(input[s+k*d]!='*')
					{
			//			Console.WriteLine("pit");
						pit=true;
					}
			//		else Console.WriteLine("No pit");
				}

				if(pit==false){Console.WriteLine("yes"); return;}
			}

		}

		Console.WriteLine("no");

	}

}

using System;

public class KingOfThieves
{

	static public void Print(int n,int s,int k,int d)
	{
		string markers="";
		for(int i=0;i<s;++i)markers+=".";
		for(int k2=0;k2<=3;++k2)
			{
			if(k2==k)	markers+="|";
			else		markers+="-";
			for(int i=1;i<d && s+k2*d+i<n;++i)markers+=".";
			}
		for(int i=d;s+3*d+i<n;++i)markers+=".";
		Console.WriteLine(markers);
	}

	static public void Main()
	{
		string input=Console.ReadLine();

		int n	=	input.Length;

		for(int d=n/3;d>=1;--d)
		{
			for(int s=0;s<n-3*d;++s)
			{
				bool pit=false;

				for(int k=0;k<=3;++k)
				{

			//		Console.WriteLine(input);
			//		Print(n,s,k,d);

					if(input[s+k*d]!='*')
					{
			//			Console.WriteLine("pit");
						pit=true;
					}
			//		else Console.WriteLine("No pit");
				}

				if(pit==false){Console.WriteLine("Yes"); return;}
			}

		}

		Console.WriteLine("No");

	}

}

using System;

public class KingOfThieves
{

	static public void Print(int n,int s,int k,int d)
	{
		string markers="";
		for(int i=0;i<s;++i)markers+=".";
		for(int k2=0;k2<=3;++k2)
			{
			if(k2==k)	markers+="|";
			else		markers+="-";
			for(int i=1;i<d && s+k2*d+i<n;++i)markers+=".";
			}
		for(int i=d;s+3*d+i<n;++i)markers+=".";
		Console.WriteLine(markers);
	}

	static public void Main()
	{
		Console.ReadLine();
		string input=Console.ReadLine();

		int n	=	input.Length;

		for(int d=n/3;d>=1;--d)
		{
			for(int s=0;s<n-3*d;++s)
			{
				bool pit=false;

				for(int k=0;k<=3;++k)
				{

			//		Console.WriteLine(input);
			//		Print(n,s,k,d);

					if(input[s+k*d]!='*')
					{
			//			Console.WriteLine("pit");
						pit=true;
					}
			//		else Console.WriteLine("No pit");
				}

				if(pit==false){Console.WriteLine("Yes"); return;}
			}

		}

		Console.WriteLine("No");

	}

}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            string str = Console.ReadLine();
            int t = 1,
                ind = 0,
                k = 0;
            bool y = true;
            for (int i = 0; i < n; i++)
            {
                if (str[i] == '*')
                { ind = i; break; }
            }

            for (int i = ind+t; i<n ; i+=t)
            {
                if (str[i] == '*')
                { k++; }
                else
                { t++; i = ind + t; k = 0;  }
                if (k == 3)
                { Console.WriteLine("yes"); y = false; break; }
            }
            if (y == true)
                Console.WriteLine("no");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            string str = Console.ReadLine();
            int t = 1, ind = 0;
            bool y = true;
            for (int i = 0; i < n; i++)
            {
                if (str[i] == '*')
                { ind = i; break; }
            }
            for (int i = ind; i+(t*4) < n; i += t)
            {
                if (str[i] == '*' && str[i + t] == '*' && str[i + t * 2] == '*'
                    && str[i + t * 3] == '*' && str[i + t * 4] == '*')
                {
                    Console.WriteLine("yes");
                    y = false;
                    break;
                }
            }
            if (y == true)
                Console.WriteLine("no");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            string str = Console.ReadLine();
            int t = 1,
                ind = 0,
                k = 0,
                vr = 0;
            bool y = true;

            while (ind + (t * 3) < n && y)
            {
                t = 1;
                for (int j = ind+vr; j < n; j++)
                {
                  if (str[j] == '*')
                  { ind = j; break; }
                }
                vr = 1;
                for (int i = ind + t; ind + (t * 3) < n;)
                {
                    if (str[i] == '*')
                    { k++; i += t; }
                    else
                    {
                        t++;
                        i = ind + t;
                        k = 0;
                    }
                    if (k == 3)
                    { Console.WriteLine("yes"); y = false; break; }
                }
            }
            if (y)
                Console.WriteLine("no");
        }
    }
}

using System;
using System.IO;
using System.Text;

namespace King_of_Thieves
{
    internal class Program
    {
        private static readonly StreamReader reader = new StreamReader(Console.OpenStandardInput(1024*10), Encoding.ASCII, false, 1024*10);
        private static readonly StreamWriter writer = new StreamWriter(Console.OpenStandardOutput(1024*10), Encoding.ASCII, 1024*10);

        private static void Main(string[] args)
        {
            reader.ReadLine();
            string s = reader.ReadLine();

            bool ok = false;
            for (int i = 0; !ok && i < s.Length; i++)
            {
                if (s[i] == '*')
                {
                    for (int j = (s.Length - i - 1)/4; j > 0; j--)
                    {
                        bool f = true;
                        for (int k = 0; k < 4; k++)
                        {
                            if (s[i+k*j]!='*')
                            {
                                f = false;
                                break;
                            }
                        }
                        if(f)
                        {
                            ok = true;
                            break;
                        }
                    }
                }
            }

            writer.WriteLine("{0}", ok ? "yes" : "no");
            writer.Flush();
        }
    }
}

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

namespace _526A
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            string input = Console.ReadLine();
            bool[] a = new bool[n];
            for (int i = 0; i < n; i++) a[i] = input[i] == '*';

            bool result = false;
            for (int i = 0; i < n - 4 && !result; i++)
            {
                for (int step = 1; step < (int)Math.Ceiling(n / 4D); step++)
                {
                    int jumps = 0;
                    while (jumps < 4)
                    {
                        if (!a[i + jumps * step])
                            break;
                        else
                            jumps++;
                    }

                    if (jumps == 4)
                    {
                        result = true;
                        break;
                    }
                }
            }

            Console.WriteLine(result ? "yes" : "no");
            //Console.ReadLine();
        }
    }
}