In this problem you will meet the simplified model of game King of Thieves.In a new ZeptoLab game called "King of Thieves" your aim is to reach a chest with gold by controlling your character, avoiding traps and obstacles on your way.  An interesting feature of the game is that you can design your own levels that will be available to other players. Let's consider the following simple design of a level.A dungeon consists of n segments located at a same vertical level, each segment is either a platform that character can stand on, or a pit with a trap that makes player lose if he falls into it. All segments have the same length, platforms on the scheme of the level are represented as '*' and pits are represented as '.'. One of things that affects speedrun characteristics of the level is a possibility to perform a series of consecutive jumps of the same length. More formally, when the character is on the platform number i1, he can make a sequence of jumps through the platforms i1 < i2 < ... < ik, if i2 - i1 = i3 - i2 = ... = ik - ik - 1. Of course, all segments i1, i2, ... ik should be exactly the platforms, not pits. Let's call a level to be good if you can perform a sequence of four jumps of the same length or in the other words there must be a sequence i1, i2, ..., i5, consisting of five platforms so that the intervals between consecutive platforms are of the same length. Given the scheme of the level, check if it is good.

The first line contains integer n (1 ≤ n ≤ 100) — the number of segments on the level. Next line contains the scheme of the level represented as a string of n characters '*' and '.'.

If the level is good, print the word "yes" (without the quotes), otherwise print the word "no" (without the quotes).

NoteIn the first sample test you may perform a sequence of jumps through platforms 2, 5, 8, 11, 14.

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;

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.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.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
    }
}

// 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.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.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 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.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");
        }
    }
}

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;
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();
        }
    }
}