using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace C_sarp_tests
{
    class Program
    {
        private static int counter = 1;
        static void Main(string[] args)
        {
            int num = Convert.ToInt32(Console.ReadLine());

            while (num > 0)
            {
                num = Important(num);
            }

            Console.WriteLine(counter);
        }

        private static int Important(int n)
        {
            n++;
            if (n % 10 != 0)
            {
                counter++;

            }

            while (n % 10 == 0)
            {
                n /= 10;

                if (n > 9 && n % 10 != 0)
                {
                    counter++;

                }
                else if (n <= 9)
                {
                    counter += 9;

                    return 0;
                }
            }

            return n;
        }


using System;
using System.Text;

namespace UdsuTest
{
    class Program
    {
        public static void Main(string[] args)
        {
            Int64 input =  Int64.Parse(Console.ReadLine());

            Int64 answer = 1;

            while (input >= 10L)
            {
                Int64 right = input % 10L;

                answer = 9L - right + answer;

                input /= 10;
            }

            answer += 9;

            Console.WriteLine(answer);
        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using static System.Console;
using static System.Convert;
using static System.Math;
//using Debug;
//using static System.Globalization.CultureInfo;

class Program
{
    static void Main(string[] args)
    {
        Solve();
        //WriteLine(Solve());
    }
    static void Solve()
    {
        var num = Input.num;
        var ct = 0;
        while ((num-1)/10 != 0)
        {
            ct++;
            num = f(num);
        }
        WriteLine(ct+9);
    }
    static int f(int num)
    {
        var s = (num + 1).ToString();
        var q = 0;
        while (q != s.Length && s[s.Length-q-1] == '0')
            q++;
        return int.Parse(s.Substring(0, s.Length - q));
    }
}

public class Input
{
    public static string read => ReadLine();
    public  static int[] ar => Array.ConvertAll(read.Split(' '), int.Parse);
    public  static int num => ToInt32(read);
    public static long[] arL => Array.ConvertAll(read.Split(' '), long.Parse);
    public  static long numL => ToInt64(read);
    public static char[][] gred(int h)
        => Enumerable.Repeat(0, h).Select(v => read.ToCharArray()).ToArray();
    public static int[][] ar2D(int num)
        => Enumerable.Repeat(0, num).Select(v => ar).ToArray();
    public static long[][] arL2D(int num)
        => Enumerable.Repeat(0, num).Select(v => arL).ToArray();
    public const long Inf = (long)1e18;
    public const double eps = 1e-6;
    public  const string Alfa = "abcdefghijklmnopqrstuvwxyz";
    public  const int MOD = 1000000007;
}


using System;
using System.Collections.Generic;

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            int number;
            int count = 2;

            bool sem = false;
            number = int.Parse(Console.ReadLine());
            if (number == 9)
            {
                count = 0;
                number++;
                sem = true;
            }
            else
            {
                number++;
                count++;
            }

            while(true)
            {
                if(number == 9 && sem == false)
                {
                    sem = true;
                }
                if(number == 9 && sem == true)
                {
                    break;
                }

                if (number % 10 == 0)
                {
                    number = number / 10;
                }
                else
                {
                    number++;
                    count++;
                }
            }

            Console.WriteLine(count);

            //Console.ReadLine();
        }
    }
}


using System;
using System.Collections.Generic;
namespace codef
{
    class Program
    {
        static void Main(string[] args)
        {
            int number = int.Parse(Console.ReadLine());
            List<int> list = new List<int>();
            int counter = 0;
            while(!list.Contains(number)){
                if(number%10 == 0) number/=10;
                else {
                    list.Add(number);
                    counter++;
                    number++;
                }
            }
            Console.WriteLine(counter);
        }
    }
}


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

namespace b
{
    class Program
    {

        class Point
        {
            public Point(int x, int y)
            {
                this.x = x;
                this.y = y;
            }

            public bool Eq(Point an)
            {
                return (this.x == an.x && this.y == an.y);
            }

            public int x, y;
        }

        static void Main(string[] args)
        {
            string way = Console.ReadLine();
            Point[] pts = new Point[way.Length+1];
            pts[0] = new Point(0, 0);
            bool bug = false;
            for (int i = 0; i < way.Length; i++)
            {

                switch (way[i])
                {
                    case 'L':
                        pts[i + 1] = new Point(pts[i].x-1, pts[i].y);
                        break;
                    case 'R':
                        pts[i + 1] = new Point(pts[i].x+1, pts[i].y);
                        break;
                    case 'U':
                        pts[i + 1] = new Point(pts[i].x, pts[i].y+1);
                        break;
                    case 'D':
                        pts[i + 1] = new Point(pts[i].x, pts[i].y-1);
                        break;
                }

                for (int j = 0; j < i + 1; j++)
                {
                    if (pts[i+1].Eq(pts[j]))
                    {
                        bug = true;
                        break;
                    }
                }
                if (bug) break;
            }
            if (bug) Console.WriteLine("BUG");
            else Console.WriteLine("OK");
        }
    }
}


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

namespace Codeforces
{
	internal class Template
	{
		private void Solve()
		{
			var n = cin.NextInt();
			var k = cin.NextInt();
			var a = new int[n];
			var pos = new Queue<int>[n + 10];
			for (var i = 0; i < pos.Length; i++)
			{
				pos[i] = new Queue<int>();
			}
			for (var i = 0; i < n; i++)
			{
				a[i] = cin.NextInt();
				pos[a[i]].Enqueue(i);
			}
			var have = new HashSet<int>();
			var timesNeeded = new SortedDictionary<int, int>();
			var res = 0;
			for (var i = 0; i < a.Length; i++)
			{
				if (!have.Contains(a[i]))
				{
					if (have.Count == k)
					{
						var first = timesNeeded.First();
						timesNeeded.Remove(first.Key);
						have.Remove(first.Value);
					}
					have.Add(a[i]);
					if (i != pos[a[i]].Peek())
					{
						throw new AccessViolationException();
					}
					pos[a[i]].Dequeue();
					if (!pos[a[i]].Any())
					{
						timesNeeded.Add(-1000000000 + i, a[i]);
					}
					else
					{
						timesNeeded.Add(-pos[a[i]].Peek(), a[i]);
					}
					res++;
				}
				else
				{
					pos[a[i]].Dequeue();
				}
			}
			Console.WriteLine(res);
		}

		private static readonly Scanner cin = new Scanner();

		private static void Main()
		{
#if DEBUG
			var inputText = File.ReadAllText(@"..\..\input.txt");
			var testCases = inputText.Split(new[] { "input" }, StringSplitOptions.RemoveEmptyEntries);
			var consoleOut = Console.Out;
			for (var i = 0; i < testCases.Length; i++)
			{
				var parts = testCases[i].Split(new[] { "output" }, StringSplitOptions.RemoveEmptyEntries);
				Console.SetIn(new StringReader(parts[0].Trim()));
				var stringWriter = new StringWriter();
				Console.SetOut(stringWriter);
				var sw = Stopwatch.StartNew();
				new Template().Solve();
				sw.Stop();
				var output = stringWriter.ToString();

				Console.SetOut(consoleOut);
				var color = ConsoleColor.Green;
				var status = "Passed";
				if (parts[1].Trim() != output.Trim())
				{
					color = ConsoleColor.Red;
					status = "Failed";
				}
				Console.ForegroundColor = color;
				Console.WriteLine("Test {0} {1} in {2}ms", i + 1, status, sw.ElapsedMilliseconds);
			}
			Console.ReadLine();
			Console.ReadKey();
#else
			new Template().Solve();
			Console.ReadLine();
#endif
		}
	}

	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.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;

namespace Codeforces
{
	internal class Template
	{
		private void Solve()
		{
			var n = cin.NextInt();
			var k = cin.NextInt();
			var a = new int[n];
			var pos = new Queue<int>[n + 10];
			for (var i = 0; i < pos.Length; i++)
			{
				pos[i] = new Queue<int>();
			}
			for (var i = 0; i < n; i++)
			{
				a[i] = cin.NextInt();
				pos[a[i]].Enqueue(i);
			}
			var have = new HashSet<int>();
			var timesNeeded = new SortedDictionary<int, int>();
			var res = 0;
			for (var i = 0; i < a.Length; i++)
			{
				if (!have.Contains(a[i]))
				{
					if (have.Count == k)
					{
						var first = timesNeeded.First();
						timesNeeded.Remove(first.Key);
						have.Remove(first.Value);
					}
					have.Add(a[i]);
					if (i != pos[a[i]].Dequeue())
					{
						throw new AccessViolationException();
					}
					if (!pos[a[i]].Any())
					{
						timesNeeded.Add(-1000000000 + i, a[i]);
					}
					else
					{
						timesNeeded.Add(-pos[a[i]].Peek(), a[i]);
					}
					res++;
				}
			}
			Console.WriteLine(res);
		}

		private static readonly Scanner cin = new Scanner();

		private static void Main()
		{
#if DEBUG
			var inputText = File.ReadAllText(@"..\..\input.txt");
			var testCases = inputText.Split(new[] { "input" }, StringSplitOptions.RemoveEmptyEntries);
			var consoleOut = Console.Out;
			for (var i = 0; i < testCases.Length; i++)
			{
				var parts = testCases[i].Split(new[] { "output" }, StringSplitOptions.RemoveEmptyEntries);
				Console.SetIn(new StringReader(parts[0].Trim()));
				var stringWriter = new StringWriter();
				Console.SetOut(stringWriter);
				var sw = Stopwatch.StartNew();
				new Template().Solve();
				sw.Stop();
				var output = stringWriter.ToString();

				Console.SetOut(consoleOut);
				var color = ConsoleColor.Green;
				var status = "Passed";
				if (parts[1].Trim() != output.Trim())
				{
					color = ConsoleColor.Red;
					status = "Failed";
				}
				Console.ForegroundColor = color;
				Console.WriteLine("Test {0} {1} in {2}ms", i + 1, status, sw.ElapsedMilliseconds);
			}
			Console.ReadLine();
			Console.ReadKey();
#else
			new Template().Solve();
			Console.ReadLine();
#endif
		}
	}

	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.Collections.Generic;
using Debug = System.Diagnostics.Debug;
using SB = System.Text.StringBuilder;
//using System.Numerics;
using Number = System.Int64;
using static System.Math;
//using static MathEx;
//using P = System.Collections.Generic.KeyValuePair<int, int>;
namespace Program
{
    public class Solver
    {
        public void Solve()
        {
            var n = ri;
            var k = ri;
            var a = Enumerate(n, x => ri - 1);
            var rand = new Random(1);
            //a = Enumerate(n, x => rand.Next() % n);
            //naive(n, k, a);

            var last = Enumerate(n, x => n + 1);
            var next = new int[n];
            for (int i = n - 1; i >= 0; i--)
            {
                next[i] = last[a[i]];
                last[a[i]] = i;
            }

            var prev = new int[n];
            var cnt = 0;
            Debug.WriteLine(a.AsJoinedString());
            var s = new SortedSet<long>();
            var pq = new SortedSet<long>();
            for (int i = 0; i < n; i++)
            {
                if (s.Add(a[i]))
                {
                    Debug.WriteLine(a[i]);
                    cnt++;
                    pq.Add(next[i] * 1000000L + a[i]);
                    if (s.Count > k)
                    {
                        var ma = pq.Max;
                        Debug.WriteLine("!{0}", ma);
                        pq.Remove(ma);
                        s.Remove(ma % 1000000L);
                    }
                }
                else
                {
                    pq.Remove(i * 1000000L + a[i]);
                    pq.Add(next[i] * 1000000L + a[i]);
                }
            }
            IO.Printer.Out.WriteLine(cnt);
        }
        void naive(int n, int k, int[] a)
        {
            var dp = new int[1 << n];
            for (int i = 0; i < 1 << n; i++)
                dp[i] = 1000000;
            dp[0] = 0;
            foreach (var x in a)
            {
                var next = Enumerate(1 << n, y => 1000000);
                for (int i = 0; i < 1 << n; i++)
                {
                    if (dp[i] >= 1000000) continue;
                    var cnt = 0;
                    for (int j = 0; j < n; j++)
                        if ((i >> j & 1) == 1) cnt++;
                    if (cnt > k) continue;
                    if ((i >> x & 1) == 1)
                        next[i] = Min(next[i], dp[i]);
                    else
                    {
                        var nmask = i | 1 << x;
                        if (cnt == k)
                            for (int j = 0; j < n; j++)
                            {
                                if ((i >> j & 1) == 1)
                                {
                                    var nnmask = nmask ^ (1 << j);
                                    next[nnmask] = Min(next[nnmask], dp[i] + 1);
                                }

                            }
                        else
                        {
                            next[nmask] = Min(next[nmask], dp[i] + 1);
                        }
                    }
                }
                dp = next;
            }
            IO.Printer.Out.WriteLine(dp.Min());

        }
        //*
        int ri => sc.Integer();
        long rl => sc.Long();
        double rd => sc.Double();
        string rs => sc.Scan();
        char rc => sc.Char();

        [System.Diagnostics.Conditional("DEBUG")]
        void put(params object[] a) => Debug.WriteLine(string.Join(" ", a));

        //*/
        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;
        }
        static void Swap<T>(ref T a, ref T b)
        {
            var tmp = a;
            a = b;
            b = tmp;
        }
    }
}

#region main

static class Ex
{
    public static string AsString(this IEnumerable<char> ie)
    {
        return new string(ie.ToArray());
    }

    public static string AsJoinedString<T>(this IEnumerable<T> ie, string st = " ")
    {
        return string.Join(st, ie);
    }

    public static void Main()
    {
        var solver = new Program.Solver();
        solver.Solve();
        Program.IO.Printer.Out.Flush();
    }
}

#endregion
#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(Stream stream) : base(stream, new UTF8Encoding(false, true))
        {
        }

        public Printer(Stream stream, Encoding encoding) : base(stream, encoding)
        {
        }

        public void Write<T>(string format, T[] source)
        {
            base.Write(format, source.OfType<object>().ToArray());
        }

        public void WriteLine<T>(string format, 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;

        public bool IsEndOfStream
        {
            get { return isEof; }
        }

        private byte read()
        {
            if (isEof) return 0;
            if (ptr < len) return buf[ptr++];
            ptr = 0;
            if ((len = str.Read(buf, 0, 1024)) > 0) return buf[ptr++];
            isEof = true;
            return 0;
        }

        public char Char()
        {
            byte b;
            do b = read(); while ((b < 33 || 126 < b) && !isEof);
            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 string ScanLine()
        {
            var sb = new StringBuilder();
            for (var b = Char(); b != '\n'; b = (char)read())
                if (b == 0) break;
                else if (b != '\r') sb.Append(b);
            return sb.ToString();
        }

        public long Long()
        {
            if (isEof) return long.MinValue;
            long ret = 0;
            byte b;
            var ng = false;
            do b = read(); while (b != 0 && b != '-' && (b < '0' || '9' < b));
            if (b == 0) return long.MinValue;
            if (b == '-')
            {
                ng = true;
                b = read();
            }
            for (; ; b = read())
            {
                if (b < '0' || '9' < b)
                    return ng ? -ret : ret;
                ret = ret * 10 + b - '0';
            }
        }

        public int Integer()
        {
            return (isEof) ? int.MinValue : (int)Long();
        }

        public double Double()
        {
            var s = Scan();
            return s != "" ? double.Parse(s, CultureInfo.InvariantCulture) : double.NaN;
        }

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

#endregion

#region BinaryHeap
public class PriorityQueue<T>
{
    readonly List<T> heap = new List<T>();
    readonly IComparer<T> cmp;
    public PriorityQueue() { cmp = Comparer<T>.Default; }
    public PriorityQueue(Comparison<T> f) { cmp = Comparer<T>.Create(f); }
    public PriorityQueue(IComparer<T> c) { cmp = c; }
    public void Enqueue(T item)
    {

        var i = heap.Count;
        heap.Add(item);
        while (i > 0)
        {
            var p = (i - 1) / 2;
            if (cmp.Compare(heap[p], item) <= 0)
                break;
            heap[i] = heap[p];
            i = p;
        }
        heap[i] = item;

    }
    public T Dequeue()
    {
        var ret = heap[0];
        var i = 0;
        var x = heap[heap.Count - 1];

        while ((i * 2) + 1 < heap.Count - 1)
        {
            var a = i * 2 + 1;
            var b = i * 2 + 2;
            if (b < heap.Count - 1 && cmp.Compare(heap[b], heap[a]) < 0) a = b;
            if (cmp.Compare(heap[a], x) >= 0)
                break;
            heap[i] = heap[a];
            i = a;
        }
        heap[i] = x;
        heap.RemoveAt(heap.Count - 1);
        return ret;

    }
    public T Peek() { return heap[0]; }
    public int Count { get { return heap.Count; } }
    public bool Any() { return heap.Count > 0; }
    public T[] Items
    {
        get
        {
            var ret = heap.ToArray();
            Array.Sort(ret, cmp);
            return ret;
        }
    }
}
#endregion


using System;
using System.Collections.Generic;
using System.Globalization;

namespace Codeforces
{
    internal static class Program
    {
        private static void Main()
        {
            var m = long.Parse(Console.ReadLine());

            var result = new List<long>();

            for (var i = 0; i < 100000; i++)
            {
                var n = GetDivisorCount(Factorial(i), 5);

                if (n == m)
                {
                    result.Add(i);
                }
                else if (m < n)
                {
                    break;
                }
            }

            Print(result.Count);

            if (result.Count > 0)
            {
                Print(string.Join(" ", result));
            }
        }

        // Returns how many times 'n' can be divided by 'divisor'.
        private static long GetDivisorCount(long n, long divisor)
        {
            long count = 0;

            while (0 < n && n % divisor == 0)
            {
                n /= divisor;
                count++;
            }

            return count;
        }

        private static long Factorial(long n)
        {
            var acc = 1L;
            for (var i = 1L; i <= n; i++) { acc *= i; }
            return acc;
        }

        private static void Print(string s) { Console.WriteLine(s); }
        private static void Print(long x) { Console.WriteLine(x.ToString(CultureInfo.InvariantCulture)); }
        private static void Print(double x) { Console.WriteLine(x.ToString(CultureInfo.InvariantCulture)); }

        private static string S(long x) { return x.ToString(CultureInfo.InvariantCulture); }
        private static string S(double x) { return x.ToString(CultureInfo.InvariantCulture); }
    }
}


using System;
using System.Globalization;
using System.Linq;

namespace Codeforces
{
    internal static class Program
    {
        private static void Main()
        {
            var m = long.Parse(Console.ReadLine());
            var count = 0L;

            long i;
            for (i = 1; count < m; i++)
            {
                count = GetCount(i);
            }

            if (count == m)
            {
                Print(5);
                Print(string.Join(" ", Enumerable.Range(i, 5)));
            }
            else
            {
                Print(0);
            }
        }

        private static long GetCount(long n)
        {
            var count = 0L;
            for (var t = 5L; t <= n; t *= 5) { count += n / t; }
            return count;
        }

        private static void Print(string s) { Console.WriteLine(s); }
        private static void Print(long x) { Console.WriteLine(x.ToString(CultureInfo.InvariantCulture)); }
    }
}


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

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

            int factorial = 0;
            int zeros = 0;
            while(zeros < trailing) {
                factorial += 5;

                if(factorial % 5 == 0) {
                    zeros++;
                }
                int pow = 2;
                while(factorial == Math.Pow(5, pow)) {
                    zeros++;
                }
            }

            if(zeros == trailing) {
                Console.WriteLine(5);
                for(int i = 0; i < 5; i++) {
                    Console.Write(factorial + i + " ");
                }
                Console.WriteLine();
            } else {
                Console.WriteLine("0");
            }
        }
    }
}


using System;

namespace Task_45A
{
    class Program
    {
        static void Main(string[] args)
        {
            string currentMonth = Console.ReadLine();
            int timeRemaining = int.Parse(Console.ReadLine());
            string[] months = { "January", "February", "March", "April", "May", "June",
                           "July", "August", "September", "October", "November", "December" };
            string ans = ".";
            for(int i = 0; i < 12; i++)
            {
                if (months[i] == currentMonth)
                {
                    if (i + timeRemaining % 12 > 12)
                    {
                        ans = months[i + timeRemaining % 12 - 12];
                        break;
                    }

                    else
                    {
                        ans = months[i + timeRemaining % 12];
                        break;
                    }
                }
            }
            Console.WriteLine(ans);
        }
    }
}


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

namespace Olimp5
{
    struct DP
    {
        public bool b;
        public string s;
        public DP(bool b,string s)
        {
            this.b = b;
            this.s = s;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            string word = Console.ReadLine();
            int n = int.Parse(Console.ReadLine());
            string[] dict = new string[n];
            for (int i = 0;i < n; i++)
            {
                dict[i] = Console.ReadLine();
            }
            DP[] dp = new DP[word.Length + 1];
            dp[0] = new DP(true,"");
            for (int i = 1;i < dp.Length; i++)
            {
                foreach (var s in dict)
                {
                    if (i >= s.Length && dp[i - s.Length].b)
                    {
                        for (int j = 0;j < s.Length; j++)
                        {
                            if (s[j]  != word[i - s.Length + j])
                            {
                                dp[i] = new DP(false, "");
                                goto BREAK1;
                            }
                        }
                        dp[i] = new DP(true, dp[i - s.Length].s + s + " ");
                        break;
                    }
                    BREAK1:;
                }
            }
            Console.WriteLine(dp.Last().s);
        }
    }
}


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

namespace Square
{
class Program
{
static void Main(string[] args){
int n, x, y;
var coll = str.Split(' ');
n = Convert.ToInt32(coll[0]);
x = Convert.ToInt32(coll[1]);
y = Convert.ToInt32(coll[2]);
Console.WriteLine(((x == n / 2 || x == n / 2 + 1) && (y == n / 2 || y == n / 2 + 1) ? "NO" : "YES"));
}
}
}


            int n, x, y;
            string str = Console.ReadLine();
            var coll = str.Split(' ');
            n = Convert.ToInt32(coll[0]);
            x = Convert.ToInt32(coll[1]);
            y = Convert.ToInt32(coll[2]);
            Console.WriteLine(((x == n / 2 || x == n / 2 + 1) && (y == n / 2 || y == n / 2 + 1) ? "NO" : "YES"));


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

namespace CodeForcesTemplate
{
    class Program
    {
        static int n, m, k;

        static void Main(string[] args)
        {

            LoadInput();

            Solve();
        }

        private static void Solve()
        {
            if (k > n + m - 2)
            {
                Console.WriteLine(-1);
                return;
            }
            int max = -1;
            for (int x = 1; x < n; x++)
            {
                int y = k + 2 - x;
                int cur = (int) (Math.Floor((double)n / x) * Math.Floor((double)m / y));
                if (cur > max)
                {
                    max = cur;
                }
            }
            Console.WriteLine(max);
        }

        private static void LoadInput()
        {
            var inp = Console.ReadLine().Split(' ').Select(x => Convert.ToInt32(x)).ToArray();
            n = inp[0];
            m = inp[1];
            k = inp[2];
            if (n > m)
            {
                m = inp[0];
                n = inp[1];
            }
        }
    }

    static class Helpers
    {
        public static void Print<T>(this IEnumerable<T> source)
        {
            foreach (var item in source)
            {
                Console.Write("{0} ", item.ToString());
            }
            Console.WriteLine();
        }
    }
}


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

class Program
{
	private static void SolveC()
    {
        var n = RI();
        //var m = RIA(n);
        long ans = 0;
        for (int i = 0; i < n; i++)
        {

        }

        Console.WriteLine(ans);
    }

    private static void SolveB()
    {
        Console.ReadLine();
        var s = Console.ReadLine();
        int count = 0;
        int mAX = 0;

        while (s.Contains('('))
        {
            int p1 = s.IndexOf('(');
            int p2 = s.IndexOf(')');

            string ss = s.Substring(p1 + 1, p2 - p1 - 1);
            count += (ss.Split('_').Where(qwe => qwe.Length > 0).Count());

            s = s.Remove(p1, p2 - p1 + 1).Insert(p1, "_");
        }

        var words = s.Split('_').Where(qwe => qwe.Length > 0).ToArray();
        if (words.Length > 0)
            mAX = words.Max(ww => ww.Length);

        Console.WriteLine(mAX + " " + count);
    }
	static void Main(string[] args)
    {

        SolveB();
        //SolveC();
    }

}


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

namespace taskA
{
    class Program
    {
        double aMain(string[] args)
        {
            int n;
            string s;
            Console.WriteLine("Введите n");
            n = int.Parse(Console.ReadLine());
            Console.WriteLine("Введите s");
            s = Console.ReadLine();
            string answer = "";
            double counter=0;
            for (int i = 0; i < n; i++)
            {
                if (counter == 0)
                    if (s[i].ToString() == "0") { answer += i.ToString(); counter = i;}
                    else;
                else if(s[i].ToString() == "0") { answer += (i - counter - 1).ToString(); counter = i; }

            }
            if (counter == 0) answer = n.ToString();
            else
            answer+=(n-1-counter).ToString();
            counter = int.Parse(answer);
            return counter;
            Console.WriteLine(counter);
        }
    }
}


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

public class Program
{
	public static void Main()
	{
        solve_441A();
	}

	public static void solve_441A()
	{
		int n = Convert.ToInt32(Console.ReadLine());
		int a = Convert.ToInt32(Console.ReadLine());
		int b = Convert.ToInt32(Console.ReadLine());
		int c = Convert.ToInt32(Console.ReadLine());

		n = n - 1;
		int minStart = Math.Min(a, b);
		int totalLength = 0;
		if (minStart <= c)
		{
			totalLength = minStart * n;
		}
		else
		{
			totalLength = minStart + c * --n;
		}

		Console.WriteLine(totalLength);
	}
}


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

namespace Codeforces
{
    class Program
    {
        static void Main(string[] args)
        {

            string[] numbers = Console.ReadLine().Split();
            double x = Convert.ToDouble(numbers[0]);
            double y = Convert.ToDouble(numbers[1]);
            double xpow = Math.Pow(x, y);
            double ypow = Math.Pow(y, x);

            if(xpow>ypow)
            {
                Console.WriteLine(">");
            }
            else if(xpow<ypow)
            {
                Console.WriteLine("<");
            }
            else
            {
                Console.WriteLine("=");
            }

        }
    }
}


Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2013
VisualStudioVersion = 12.0.21005.1
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Codeforces8", "Codeforces8\Codeforces8.csproj", "{66360A16-3D77-4895-93AF-315EF87B6FCC}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{66360A16-3D77-4895-93AF-315EF87B6FCC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{66360A16-3D77-4895-93AF-315EF87B6FCC}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{66360A16-3D77-4895-93AF-315EF87B6FCC}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{66360A16-3D77-4895-93AF-315EF87B6FCC}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
EndGlobal


using System;

namespace CSharp
{
    public class _987B
    {
        public static void Main()
        {
            string[] tokens = Console.ReadLine().Split();

            int x = int.Parse(tokens[0]);
            int y = int.Parse(tokens[1]);

            Console.WriteLine(x == y ? '=' : y * Math.Log(x) > x * Math.Log(y) ? '>' : '<');
        }
    }
}


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

namespace Contest
{
    class Scanner
    {
        private string[] line = new string[0];
        private int index = 0;
        public string Next()
        {
            if (line.Length <= index)
            {
                line = Console.ReadLine().Split(' ');
                index = 0;
            }
            var res = line[index];
            index++;
            return res;
        }
        public int NextInt()
        {
            return int.Parse(Next());
        }
        public long NextLong()
        {
            return long.Parse(Next());
        }
        public string[] Array()
        {
            line = Console.ReadLine().Split(' ');
            index = line.Length;
            return line;
        }
        public int[] IntArray()
        {
            var array = Array();
            var result = new int[array.Length];
            for (int i = 0; i < array.Length; i++)
            {
                result[i] = int.Parse(array[i]);
            }

            return result;
        }
        public long[] LongArray()
        {
            var array = Array();
            var result = new long[array.Length];
            for (int i = 0; i < array.Length; i++)
            {
                result[i] = long.Parse(array[i]);
            }

            return result;
        }
    }

    class Program
    {
        private int X, Y;
        private void Scan()
        {
            var sc = new Scanner();
            X = sc.NextInt();
            Y = sc.NextInt();
        }

        public void Solve()
        {
            Scan();
            if (X == 1)
            {
                if (Y == 1)
                {
                    Console.WriteLine("=");
                }
                else
                {
                    Console.WriteLine("<");
                }
                return;
            }
            else if (Y == 1)
            {
                Console.WriteLine(">");
                return;
            }
            var a = Math.Log(X, Y);
            var b = (double)X / Y;
            Console.WriteLine($"{a} {b}");
            if (a > b)
            {
                Console.WriteLine(">");
            }
            else if (a < b)
            {
                Console.WriteLine("<");
            }
            else
            {
                Console.WriteLine("=");
            }
        }

        static void Main() => new Program().Solve();
    }
}


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

namespace bla
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] s = Console.ReadLine().Split();
            double x = double.Parse(s[0]);
            double y = double.Parse(s[1]);
            double a = y * Math.Log(x);
            double b = x * Math.Log(y);
            if (x == y)
            {
                Console.WriteLine("=");
                return;
            }
            if (a > b)
            {
                Console.WriteLine(">");
            }
            else if (b > a)
            {
                Console.WriteLine("<");
            }
            Console.WriteLine("=");
        }
    }
}


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

namespace codeforces
{
class Program
{
static void Main(string[] args)
{
string s = Console.ReadLine();
double x = double.Parse(s.Split(' ')[0]), y = double.Parse(s.Split(' ')[1]);
if (x > 1000 || y > 1000)
{
if (x < y)
{
Console.WriteLine(">");
}
if (x > y)
{
Console.WriteLine("<");
}
if (x == y)
{
Console.WriteLine("=");
}
}else{
double t = Math.Pow(x, y);
double h = Math.Pow(y, x);
if (t < h)
{
Console.WriteLine("<");
}
if (t > h)
{
Console.WriteLine(">");
}
if (t == h)
{
Console.WriteLine("=");
}
}
}
}
}


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

namespace ConsoleApplication3
{
    class Program
    {
        static void Main(string[] args)
        {

                string[] s = Console.ReadLine().Split(' ');
                Solution1 ss = new Solution1();
                ss.find_power_greater(Convert.ToInt32(s[0]), Convert.ToInt32(s[1]));

}
}

 public class Solution1
    {
         public void find_power_greater(int a, int b)
        {
            double ab = findapowerb(a, b);
            double ba = findapowerb(b, a);
            if (ab == ba)
            {
                Console.WriteLine("=");
            }
            if (ab > ba)
            {
                Console.WriteLine(">");
            }
            if (ab < ba)
            {
                Console.WriteLine("<");
            }
        }

        public static int findapowerb(int a, int b)
        {

             return  (b) *   (Math.Log(a) );

    }
}
}


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

namespace ConsoleApplication3
{
    class Program
    {
        static void Main(string[] args)
        {

                string[] s = Console.ReadLine().Split(' ');
                Solution1 ss = new Solution1();
                ss.find_power_greater(Convert.ToInt32(s[0]), Convert.ToInt32(s[1]));

}
}

 public class Solution1
    {
         public void find_power_greater(int a, int b)
        {
            long ab = findapowerb(a, b);
            long ba = findapowerb(b, a);

            if (ab == ba)
            {
                Console.WriteLine("=");
            }
            if (ab > ba)
            {
                Console.WriteLine(">");
            }
            if (ab < ba)
            {
                Console.WriteLine("<");
            }
        }
        public static int findapowerb(int a, int b)
        {
            return (int)(b * Math.Log(a));

        }
    }
}


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

public class CodeForces87
{
#if TEST
    // To set this go to Project -> Properties -> Build -> General -> Conditional compilation symbols: -> enter 'TEST' into text box.
    const bool testing = false;
#else
const bool testing = false;
#endif

    private static int Next()
    {
        int c;
        int res = 0;
        do
        {
            c = reader.Read();
            if (c == -1)
                return res;
        } while (c < '0' || c > '9');
        res = c - '0';
        while (true)
        {
            c = reader.Read();
            if (c < '0' || c > '9')
                return res;
            res *= 10;
            res += c - '0';
        }
    }
    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);
    class Node : IComparable
    {
        public int Index { get; set; }
        public double Value { get; set; }
        public int CompareTo(object obj)
        {
            return this.Value.CompareTo(((Node)obj).Value);
        }
    }
    static void program(TextReader input)
     {
        //var s = reader.ReadLine().TrimEnd();
        //var n = int.Parse(reader.ReadLine().TrimEnd());
        var data = reader.ReadLine().TrimEnd().Split(' ').Select(double.Parse).ToList();
        var x = data[0];
        var y = data[1];
        var res = y * Math.Log(x) / (x * Math.Log(y));
        Console.WriteLine(res == 1 ? "=" : res > 1 ? ">" : "<");
    }

    public static void Main(string[] args)
    {
        CultureInfo nonInvariantCulture = new CultureInfo("en-US");
        Thread.CurrentThread.CurrentCulture = nonInvariantCulture;
        if (!testing)
        { // set testing to false when submiting to codeforces
            program(Console.In); // write your program in 'program' function (its your new main !)
            return;
        }

        Console.WriteLine("Test Case(1) => expected :");
        Console.WriteLine("3\n2\n4\n");
        Console.WriteLine("Test Case(1) => found    :");
        program(new StringReader("4 3\n2\n3\n4\n"));
        Console.WriteLine();

        Console.WriteLine("Test Case(2) => expected :");
        Console.WriteLine("13\n3\n8\n9\n");
        Console.WriteLine("Test Case(2) => found    :");
        program(new StringReader("13 4\n10\n5\n4\n8\n"));
        Console.WriteLine();

    }
}


using System;

namespace CF_987_B
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] s = Console.ReadLine().Split();
            int x = int.Parse(s[0]);
            int y = int.Parse(s[1]);

            if(x==y)
            {
                Console.WriteLine("=");
                return;
            }

            double LogXY = y * Math.Log(x);
            double LogYX = x * Math.Log(y);
            double diff = Math.Abs(LogXY - LogYX);

            if (LogXY > LogYX)
                Console.WriteLine(">");
            else
                Console.WriteLine("<");
        }
    }
}


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

namespace A
{
	class Program
	{
		static void Main(string[] args)
		{
			int[] a = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
			int x = a[0]; int y = a[1]; int z = a[2]; int t1 = a[3]; int t2 = a[4]; int t3 = a[5];
			int walk = Math.Abs(x - y) * t1;
			int lift = Math.Abs(z - x) * t2 + t3 + Math.Abs(y - x) * t2 + t3;
			if (walk < lift) Console.WriteLine("NO");
			else Console.WriteLine("YES");
		}
	}
}


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

namespace Rextester
{
    public class Program
    {
        public static void Main(string[] args)
        {
            //Your code goes here
            int x = Console.Re();
            int y = Console.Read();
            int z = Console.Read();
            int t1 = Console.Read();
            int t2 = Console.Read();
            int t3 = Console.Read();
            if (Math.Abs(z - x) * t2 + t3 + Math.Abs(x - y) * t2 + t3 >= Math.Abs(x - y) * t1)
            {
                Console.WriteLine("YES");
            }
            else
            {
                Console.WriteLine("NO");
            }
        }
    }
}


using System;

public class Program
{
	public static void Main()
	{
            string line = Console.ReadLine();
            string[] parts = line.Split(new char[] {' '});
            int x = int.Parse(parts[0]);
            int y = int.Parse(parts[1]);
            int z = int.Parse(parts[2]);
            int t1 = int.Parse(parts[3]);
            int t2 = int.Parse(parts[4]);
            int t3 = int.Parse(parts[5]);
            if (Math.Abs(z - x) * t2 + t3 + Math.Abs(x - y) * t2 + t3 <= Math.Abs(x - y) * t1)
            {
                Console.WriteLine("YES");
            }
            else
            {
                Console.WriteLine("NO");
            }
	}
}


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

namespace Codeforces
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split(' ');

            int x = Convert.ToInt32(input[0]); // номер на котором Маша
            int y = Convert.ToInt32(input[1]); // номер куда хочет Маша
            int z = Convert.ToInt32(input[2]); // номер на котором лифт
            int t1 = Convert.ToInt32(input[3]); // время за какое проходит между этажами
            int t2 = Convert.ToInt32(input[4]); // время за которое лифт проезжает между этажами
            int t3 = Convert.ToInt32(input[5]); // время, за которое открываются и закрываются двери у лифта

            // x y z t1 t2 t3
            // 5 1 4 4  2  1
            // YES

            // x - y = f
            // 5 - 1 = 4
            // f * t1
            // 4 * 4 = 16
            // 2x - z - y = f2
            // 10 - 4 - 1 = 5
            // (f2 * t2) + 2*t3
            // 5 * 2 + 2 = 12

            int f = Math.Abs(x - y);
            int d = f * t1;

            int f2 = Math.Abs(2 * x - y - z);
            int d2 = (f2 * t2) + 2 * t3;

            if (d2 < d)
                Console.WriteLine("YES");
            else
                Console.WriteLine("NO");

        }
    }
}


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

namespace Mailru_code
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split();
            int x = Convert.ToInt32(input[0]);
            int y = Convert.ToInt32(input[1]);
            int z = Convert.ToInt32(input[2]);
            int t1 = Convert.ToInt32(input[3]);
            int t2 = Convert.ToInt32(input[4]);
            int t3 = Convert.ToInt32(input[5]);
            int elevator = Math.Abs(z - x) * t2 + t3 * 2 + Math.Abs(x-y)*t2;
            int stairs = Math.Abs(x - y) * t1;
            if(elevator<=stairs)
                Console.WriteLine("YES");
            else
                Console.WriteLine("NO");
        }
    }
}


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

namespace Elevator_or_Stairs
{
    class Program
    {
        static void Main(string[] args)
        {
            //The only line contains six integers x, y, z, t1, t2, t3(1≤x, y, z, t1, t2, t3≤1000) —
            //the floor Masha is at, the floor Masha wants to get to, the floor the elevator is located on,
            //the time it takes Masha to pass between two floors by stairs, the time it takes the elevator to
            //    pass between two floors and the time it takes for the elevator to close or open the doors.
            int[] input = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
            int currentFloor = input[0];
            int floorToGet = input[1];
            int floorWhereElevatorIs = input[2];
            int timeTakeStairesPerFloor = input[3];
            int timeTakeElevatorPerFloor = input[4];
            int timeManageDoor = input[5];

            int timeFoot = timeTakeStairesPerFloor * Math.Abs(floorToGet - currentFloor);
            int timeElevator = timeTakeElevatorPerFloor * Math.Abs(currentFloor - floorWhereElevatorIs) +
                timeTakeElevatorPerFloor * Math.Abs(floorToGet - currentFloor) + timeManageDoor;

            if (Math.Abs(currentFloor - floorWhereElevatorIs) > 1)
                timeElevator += 2 * timeManageDoor;

            Console.WriteLine(timeElevator <= timeFoot ? "YES" : "NO");
        }
    }
}


using System;

namespace mail
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] s1 = Console.ReadLine().Split(' ');
            int x = int.Parse(s1[0]);
            int y = int.Parse(s1[1]);
            int z = int.Parse(s1[2]);
            int t1 = int.Parse(s1[3]);
            int t2= int.Parse(s1[4]);
            int t3 = int.Parse(s1[5]);

            int rxy;
            if (x > y) rxy = x - y;
            else rxy = y - x;

            int rxz;
            if (x > z) rxz=x - z;
            else rxz=z - x;

            if (rxy * t1 > rxz * t2 + t3 * 3 + rxy * t2) Console.WriteLine("YES");
            else Console.WriteLine("NO");

            Console.ReadLine();
        }
    }
}


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

namespace ConsoleApp1
{

    static class Program
    {
		static double _With_lift(int start,int end,int position,int timerun,int timeopen)
		{
			int result = timerun *  (Math.Abs(position - start)) + timeopen * 3 + timerun * ( Math.Abs(start - end) );
			return result;
		}
		static double _With_lift( int start , int end , int timerun )
		{
			return (Math.Abs( start - end )) * timerun;
		}
		static void Main(string[] args)
        {
			int[] _values = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
			double a = _With_lift(_values[0] , _values[1] , _values[2] , _values[4] , _values[5]);
			double b = _With_lift(_values[0] , _values[1] , _values[3]);
			if (a< b)
				Console.WriteLine("YES");
			else
				Console.WriteLine("NO");
			Console.ReadLine();
		}
	}
}


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

namespace ConsoleApp6
{
    class Program
    {
        static void Main(string[] args)
        {
            var inputStr = Console.ReadLine();
            var values = inputStr.Split(' ').Select(x=>int.Parse(x)).ToList();
            var a = Math.Abs(values[0] - values[1]);
            Console.WriteLine(((Math.Abs(values[0] - values[2])) * values[4] + a * values[4] +
                               2 * values[5])<= (a * values[3]) ? "YES" : "NO");
            Console.ReadLine();
        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
//using System.Text;
//using System.Text.RegularExpressions;
//using System.Globalization;
//using System.Diagnostics;
using static System.Console;
//using System.Numerics;
//using static System.Math;
//using pair = Pair<int, int>;

class Program
{
    static void Main()
    {
        //SetOut(new StreamWriter(OpenStandardOutput()) { AutoFlush = false });
        new Program().solve();
        Out.Flush();
    }
    readonly Scanner cin = new Scanner();
    readonly int[] dd = { 0, 1, 0, -1, 0 }; //→↓←↑
    readonly int mod = 1000000007;
    void chmax<T>(ref T a, T b) where T : IComparable<T> { a = a.CompareTo(b) < 0 ? b : a; }
    void chmin<T>(ref T a, T b) where T : IComparable<T> { a = a.CompareTo(b) < 0 ? a : b; }

    void solve()
    {
        int x = cin.nextint;
        int y = cin.nextint;
        int z = cin.nextint;
        int t1 = cin.nextint;
        int t2 = cin.nextint;
        int t3 = cin.nextint;

        int ele = Math.Abs(z - x) * t2 + t3 * 2 + Math.Abs(y - x) * t2;
        int st = Math.Abs(x - y) * t1;

        //WriteLine(ele + " " + st);
        if (st < ele)
        {
            WriteLine("NO");
        }
        else
        {
            WriteLine("YES");
        }
    }

}

class Scanner
{
    string[] s; int i;
    readonly char[] cs = new char[] { ' ' };
    public Scanner() { s = new string[0]; i = 0; }
    public string[] scan { get { return ReadLine().Split(); } }
    public int[] scanint { get { return Array.ConvertAll(scan, int.Parse); } }
    public long[] scanlong { get { return Array.ConvertAll(scan, long.Parse); } }
    public double[] scandouble { get { return Array.ConvertAll(scan, double.Parse); } }
    public string next
    {
        get
        {
            if (i < s.Length) return s[i++];
            string st = ReadLine();
            while (st == "") st = ReadLine();
            s = st.Split(cs, StringSplitOptions.RemoveEmptyEntries);
            i = 0;
            return next;
        }
    }
    public int nextint { get { return int.Parse(next); } }
    public long nextlong { get { return long.Parse(next); } }
    public double nextdouble { get { return double.Parse(next); } }
    public string join<T>(IEnumerable<T> values) { return string.Join(" ", values); }
}


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

namespace Codeforces
{
    class main
    {
        static void printL(string s = "")
        {
            Console.WriteLine(s);
        }
        static void printL(int s)
        {
            Console.WriteLine(s);
        }

        static void Main(string[] args)
        {
            string s = Console.ReadLine();
            int[] a = s.Split(' ').Select(int.Parse).ToArray();
            int x = a[0], y = a[1], z = a[2], t1 = a[3], t2 = a[4], t3 = a[5];
            int te = 0, ts = 0;
            ts = Math.Abs(y - x) * t1;
            te = Math.Abs(z - x) * t2 + 3 * t3 + Math.Abs(x - y);
            if (te <= ts)
                printL("YES");
            else
                printL("NO");

            //Console.ReadKey();
        }
    }
}


/*
 * Создано в SharpDevelop.
 * Пользователь: Nours
 * Дата: 18.10.2018
 * Время: 22:09
 *
 * Для изменения этого шаблона используйте меню "Инструменты | Параметры | Кодирование | Стандартные заголовки".
 */
using System;

namespace MailCup1A
{
	class Program
	{
		public static void Main(string[] args)
		{
			string[] a=Console.ReadLine().Split();

			if((Math.Abs(Convert.ToInt32(a[2])-Convert.ToInt32(a[0]))*Math.Abs(Convert.ToInt32(a[0])-Convert.ToInt32(a[1]))*Convert.ToInt32(a[4])+3*Convert.ToInt32(a[5]))<=Math.Abs(Convert.ToInt32(a[1])-Convert.ToInt32(a[0]))*Convert.ToInt32(a[3]))
				Console.WriteLine("YES");
			else
				Console.WriteLine("NO");
		}
	}
}


namespace MailCup1A
{
    class Program
    {
        public static void Main(string[] args)
        {
            string[] a=Console.ReadLine().Split();
            if((Math.Abs(Convert.ToInt32(a[2])-Convert.ToInt32(a[1]))*Convert.ToInt32(a[4])+3*Convert.ToInt32(a[5]))<=Math.Abs(Convert.ToInt32(a[1])-Convert.ToInt32(a[0]))*Convert.ToInt32(a[3]))
                Console.WriteLine("YES");
            else
                Console.WriteLine("NO");
        }
    }
}


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

class Program
{
    public static void Main(string[] args)
    {
        PushTestData(@"
5 1 4 4 2 1
YES
1 6 6 2 1 1
NO
4 1 7 4 1 2
YES

");

        var x = RL();
        var y = RL();
        var z = RL();
        var t1 = RL();
        var t2 = RL();
        var t3 = RL();

        var lift = t2 * (Math.Abs(z - x) + Math.Abs(y - x)) + t3 * 3;
        var walk = t1 * Math.Abs(x - y);
        if (walk > lift)
            Console.WriteLine("YES");
        else
            Console.WriteLine("NO");
    }

    private const int Mod = 1000000000 + 7;

    #region Data Read

    private static int GCD(int a, int b)
    {
        if (a % b == 0) return b;
        return GCD(b, a % b);
    }

    private static List<int>[] ReadTree(int n)
    {
        return ReadGraph(n, n - 1);
    }

    private static List<int>[] ReadGraph(int n, int m)
    {
        List<int>[] g = new List<int>[n];
        for (int i = 0; i < g.Length; i++) g[i] = new List<int>();
        for (int i = 0; i < m; i++)
        {
            int a = RI() - 1;
            int b = RI() - 1;

            g[a].Add(b);
            g[b].Add(a);
        }

        return g;
    }

    private static int[,] ReadGraphAsMatrix(int n, int m)
    {
        int[,] matrix = new int[n + 1, n + 1];
        for (int i = 0; i < m; i++)
        {
            int a = RI();
            int b = RI();
            matrix[a, b] = matrix[b, a] = 1;
        }

        return matrix;
    }

    private static void Sort(ref int a, ref int b)
    {
        if (a > b) Swap(ref a, ref b);
    }

    private static void Swap(ref int a, ref int b)
    {
        int tmp = a;
        a = b;
        b = tmp;
    }

    private const int BufferSize = 1 << 16;
    private static StreamReader consoleReader;
    private static MemoryStream testData;

    private static int RI()
    {
        int ans = 0;
        int mul = 1;
        do
        {
            ans = consoleReader.Read();
            if (ans == -1)
                return 0;
            if (ans == '-') mul = -1;
        } while (ans < '0' || ans > '9');

        ans -= '0';
        while (true)
        {
            int chr = consoleReader.Read();
            if (chr < '0' || chr > '9')
                return ans * mul;
            ans = ans * 10 + chr - '0';
        }
    }

    private static ulong RUL()
    {
        ulong ans = 0;
        int chr;
        do
        {
            chr = consoleReader.Read();
            if (chr == -1)
                return 0;
        } while (chr < '0' || chr > '9');

        ans = (uint)(chr - '0');
        while (true)
        {
            chr = consoleReader.Read();
            if (chr < '0' || chr > '9')
                return ans;
            ans = ans * 10 + (uint)(chr - '0');
        }
    }

    private static long RL()
    {
        long ans = 0;
        int mul = 1;
        do
        {
            ans = consoleReader.Read();
            if (ans == -1)
                return 0;
            if (ans == '-') mul = -1;
        } while (ans < '0' || ans > '9');

        ans -= '0';
        while (true)
        {
            int chr = consoleReader.Read();
            if (chr < '0' || chr > '9')
                return ans * mul;
            ans = ans * 10 + chr - '0';
        }
    }

    private static int[] RIA(int n)
    {
        int[] ans = new int[n];
        for (int i = 0; i < n; i++)
            ans[i] = RI();
        return ans;
    }

    private static long[] RLA(int n)
    {
        long[] ans = new long[n];
        for (int i = 0; i < n; i++)
            ans[i] = RL();
        return ans;
    }

    private static char[] ReadWord()
    {
        int ans;

        do
        {
            ans = consoleReader.Read();
        } while (!((ans >= 'a' && ans <= 'z') || (ans >= 'A' && ans <= 'Z') || (ans == '*')));

        List<char> s = new List<char>();
        do
        {
            s.Add((char)ans);
            ans = consoleReader.Read();
        } while ((ans >= 'a' && ans <= 'z') || (ans >= 'A' && ans <= 'Z') || (ans == '*'));

        return s.ToArray();
    }

    private static char[] ReadString(int n)
    {
        int ans;

        do
        {
            ans = consoleReader.Read();
        } while (!((ans >= 'a' && ans <= 'z') || (ans >= 'A' && ans <= 'Z')));

        char[] s = new char[n];
        int pos = 0;
        do
        {
            s[pos++] = (char)ans;
            if (pos == n) break;
            ans = consoleReader.Read();
        } while ((ans >= 'a' && ans <= 'z') || (ans >= 'A' && ans <= 'Z'));

        return s;
    }

    private static char[] ReadStringLine()
    {
        int ans;

        do
        {
            ans = consoleReader.Read();
        } while (ans == 10 || ans == 13);

        List<char> s = new List<char>();

        do
        {
            s.Add((char)ans);
            ans = consoleReader.Read();
        } while (ans != 10 && ans != 13 && ans != -1);

        return s.ToArray();
    }

    private static char ReadLetter()
    {
        while (true)
        {
            int ans = consoleReader.Read();
            if ((ans >= 'a' && ans <= 'z') || (ans >= 'A' && ans <= 'Z'))
                return (char)ans;
        }
    }
    private static char ReadNonLetter()
    {
        while (true)
        {
            int ans = consoleReader.Read();
            if (!((ans >= 'a' && ans <= 'z') || (ans >= 'A' && ans <= 'Z')))
                return (char)ans;
        }
    }

    private static char ReadAnyOf(IEnumerable<char> allowed)
    {
        while (true)
        {
            char ans = (char)consoleReader.Read();
            if (allowed.Contains(ans))
                return ans;
        }
    }

    private static char ReadDigit()
    {
        while (true)
        {
            int ans = consoleReader.Read();
            if (ans >= '0' && ans <= '9')
                return (char)ans;
        }
    }

    private static int ReadDigitInt()
    {
        return ReadDigit() - (int)'0';
    }

    private static char ReadAnyChar()
    {
        return (char)consoleReader.Read();
    }

    private static string DoubleToString(double x)
    {
        return x.ToString(CultureInfo.InvariantCulture);
    }

    private static double DoubleFromString(string x)
    {
        return double.Parse(x, CultureInfo.InvariantCulture);
    }

    static Program()
    {
        //Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
        consoleReader = new StreamReader(Console.OpenStandardInput(BufferSize), Encoding.ASCII, false, BufferSize);
    }

    private static void PushTestData(StringBuilder sb)
    {
        PushTestData(sb.ToString());
    }
    private static void PushTestData(string data)
    {
#if TOLYAN_TEST
        if (testData == null)
        {
            testData = new MemoryStream();
            consoleReader = new StreamReader(testData);
        }

        var pos = testData.Length;
        var bytes = Encoding.UTF8.GetBytes(data);
        testData.Write(bytes, 0, bytes.Length);
        testData.Flush();
        testData.Position = pos;
#endif
    }
    #endregion
}


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

namespace prog2
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());
            bool[,] map = new bool[5,5];
            for (int i = 0; i < n;i++ )
            {
                string[] ss = Console.ReadLine().Split(' ');
                map[Convert.ToInt32(ss[0])-1, Convert.ToInt32(ss[1])-1] = true;
                map[Convert.ToInt32(ss[1])-1, Convert.ToInt32(ss[0])-1] = true;
            }
            bool flag = false;
            for (int i = 0; i < 5;i++ )
            {
                for (int j=0;j<4;j++)
                    if (map[i,j])
                    {
                        for(int q=j+1;q<5;q++)
                            if ((map[i,q]) && (map[q,j]))
                            {
                                flag = true;
                                break;
                            }
                        if (flag) break;
                    }
                if (flag) break;
            }
            if (!flag)
            {
                map[0, 0] = true;
                map[1, 1] = true;
                map[2, 2] = true;
                map[3, 3] = true;
                map[4, 4] = true;
                for (int i = 0; i < 5; i++)
                {
                    for (int j = 0; j < 4; j++)
                        if (!map[i, j])
                        {
                            for (int q = j + 1; q < 5; q++)
                                if ((!map[i, q]) && (!map[q, j]))
                                {
                                    flag = true;
                                    break;
                                }
                            if (flag) break;
                        }
                    if (flag) break;
                }
            }
            if (flag) Console.WriteLine("WIN"); else Console.WriteLine("FALSE");
        }
    }
}


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

class Program
{
    static int Main()
    {
        //citire
        string[] citire = Console.ReadLine().Split(' ');
        int x, N, y, i = 0;
        x = Convert.ToInt32(citire[0]);
        citire = Console.ReadLine().Split(' ');
        N = Convert.ToInt32(citire[0]); y = x;

        //solve
        while (y <= N)
        {
            if (y == N) { Console.WriteLine("YES"); Console.WriteLine(i); return 0; }
            y *= x; i++;
        }

        Console.WriteLine("NO");
        return 0;
    }
}


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

namespace ConsoleApp21
{
    class Program
    {
        static void Main(string[] args)
        {
            int k = Convert.ToInt32(Console.ReadLine());
            int l = Convert.ToInt32(Console.ReadLine());
            int pow = k;
            int count = 0;

                while (l>pow)
                {
                pow *= k;
                count++;
                if (pow == l)
                {
                    Console.WriteLine("YES");
                    Console.WriteLine(count);
                }

                else if (pow > l)
                {
                    Console.WriteLine("NO");
                }
            }
            if (pow == l)
            {
                Console.WriteLine("YES");
                Console.WriteLine(count);
            }
            Console.ReadKey();

        }
    }
}


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

namespace Cifera_Mark_0
{
class Program
{

static void Main(string[] args)
{
int number = Int32.Parse(Console.ReadLine());
int power = Int32.Parse(Console.ReadLine());
int count = 0;
if (power != number && power % number == 0)
{
do
{
power /= number;
if (power % number == 0)
count++;
else
{
count = 0;
break;
}
}
while (power > number);
if (count > 0)
{
Console.WriteLine("YES");
Console.WriteLine(count);
}
else Console.WriteLine("NO");
}
else if (power == number)
{
Console.WriteLine("YES");
Console.WriteLine(count);
}
else Console.WriteLine("NO");
Console.ReadLine();

}
}
}.


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

namespace ConsoleApp21
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = Convert.ToInt32(Console.ReadLine());
            int l = Convert.ToInt32(Console.ReadLine());
            int pow = k;
            int count = 0;

            if (l != a && l % a == 0)
            {
                do
                {
                    l /= a;
                    if (l % a == 0)

                        count++;

                    else
                    {
                        count = 0;
                        break;
                    }

                }
                while (l > a);

                    if (count > 0)
                    {
                        Console.WriteLine("YES");
                        Console.WriteLine(count);
                    }
                    else Console.WriteLine("NO");

            }

            else if (l == a)
            {
                Console.WriteLine("YES");
                Console.WriteLine(count);
            }
            else Console.WriteLine("NO");
            Console.ReadKey();

            }

        }
    }


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

namespace Task2
{
    class Program
    {
        static void Main()
        {
            int k = int.Parse(Console.ReadLine());
            int l = int.Parse(Console.ReadLine());
            int i = 0, number = k;

            do
            {
                if (number == l)
                {
                    Console.WriteLine("YES\n" + i);
                    break;
                }
                else
                {
                    i++;
                    number *= k;
                }

                if (number > l)
                {
                    Console.WriteLine("NO");
                    break;
                }
            }
            while (number <= l);

            Console.ReadLine();
        }
    }
}


long k = long.Parse(Console.ReadLine());
            long l = long.Parse(Console.ReadLine());

                int count = 0;
                for(long r = l;;r/=k)
                {

                    count =++count;

                if(r%k!=0||r<k)
                {
                    Console.WriteLine("no");
                    Console.ReadKey();
                    break;

                }
                else if (r == k)
                {
                    Console.WriteLine("yes");
                    Console.WriteLine(count);
                    Console.ReadKey();
                    break;
                }


using System;

namespace a
{
    class Program
    {
        static void Main(string[] args)
        {
            int k = int.Parse(Console.ReadLine());
            int l = int.Parse(Console.ReadLine());
            int la = 0;
            int o = 1;
            int i;

            for (i = 0; o < l; i++)
            {
                o = o * k;
            }
            if (o == l)
            {
                Console.WriteLine("YES");
                i = i - 1;
                Console.WriteLine(i);
            }
            else
                Console.WriteLine("NO");
        }
    }
}


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

class Program
{

    void solve()
    {

    }

    ////////////
    private void println(int[] ar)
    {
        for (int i = 0; i < ar.Length; i++)
        {
            if (i == ar.Length - 1)
                println(ar[i]);
            else
                print(ar[i] + " ");
        }
    }
    private void println(int[] ar, bool add)
    {
        int A = 0;
        if (add)
            A++;
        for (int i = 0; i < ar.Length; i++)
        {
            if (i == ar.Length - 1)
                println(ar[i] + A);
            else
                print((ar[i] + A) + " ");
        }
    }

    private void println(string Stringst)
    {
        Console.WriteLine(Stringst);
    }
    private void println(char charnum)
    {
        Console.WriteLine(charnum);
    }
    private void println(int Intnum)
    {
        Console.WriteLine(Intnum);
    }
    private void println(long Longnum)
    {
        Console.WriteLine(Longnum);
    }
    private void println(double Doublenum)
    {
        string s = Doublenum.ToString(CultureInfo.InvariantCulture);
        Console.WriteLine(s);
    }

    private void print(string Stringst)
    {
        Console.Write(Stringst);
    }
    private void print(int Intnum)
    {
        Console.Write(Intnum);
    }
    private void print(char charnum)
    {
        Console.Write(charnum);
    }
    private void print(long Longnum)
    {
        Console.Write(Longnum);
    }
    private void print(double Doublenum)
    {
        Console.Write(Doublenum);
    }

    string[] inputLine = new string[0];
    int inputInd = 0;
    string nextLine()
    {
        return Console.ReadLine();
    }
    void readInput()
    {
        if (inputInd != inputLine.Length)
            throw new Exception();
        inputInd = 0;
        inputLine = Console.ReadLine().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
        if (inputLine.Length == 0)
            readInput();

    }
    int nextInt()
    {
        if (inputInd == inputLine.Length)
            readInput();
        return int.Parse(inputLine[inputInd++]);
    }
    long nextLong()
    {
        if (inputInd == inputLine.Length)
            readInput();
        return long.Parse(inputLine[inputInd++]);
    }
    double nextDouble()
    {
        if (inputInd == inputLine.Length)
            readInput();
        return double.Parse(inputLine[inputInd++]);
    }
    string nextString()
    {
        if (inputInd == inputLine.Length)
            readInput();
        return inputLine[inputInd++];
    }
    static void Main(string[] args)
    {
        Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
        new Program().solve();
    }
}


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

namespace Codeforces
{
    class A
    {
      static void Main(string[] args)
      {
         string s = Console.ReadLine();
         int num = 0;
         for(int i=0;i<s.Length-1;i++)
         {
            if(IfKFollowsV(s[i],s[i+1]))
            {
               num++;
            }
         }
         if(s.Length<3)
         {
            if((s[0]=='V'&&s[1]=='V')||(s[0]=='K'&&s[1]=='K'))
             num++;
             Console.WriteLine(num);
             return;
         }
         for(int i=0;i<s.Length-2;i++)
         {
            if(IfKFollowsK(s[i],s[i+1],s[i+2]))
            {
               num++;
               break;
            }
         }

         Console.WriteLine(num);
      }

      static bool IfKFollowsV(char a,char b)
      {
         return(a=='V'&&b=='K');
      }

      static bool IfKFollowsK(char a,char b,char c)
      {
         return(a=='V'&&b=='V'&&c=='V')||(a=='K'&&b=='K'&&c=='K');
      }

    }
}


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

namespace ConsoleApplication5
{
    class Program
    {
        static readonly char[] spaceCharArray = new[] { ' ' };
        static readonly Func<int[]> ReadArrInt32 = () => Console.ReadLine().Split(spaceCharArray).Select(int.Parse).ToArray();
        static readonly Func<long[]> ReadArrInt64 = () => Console.ReadLine().Split(spaceCharArray).Select(long.Parse).ToArray();
        static readonly Func<double[]> ReadArrDouble = () => Console.ReadLine().Split(spaceCharArray).Select(double.Parse).ToArray();

        static void Main()
        {
            var data = ReadArrInt64();
            long n = data[0], a = data[1], b = data[2], p = data[3], q = data[4], nok = 0;
            long answer = (n / a) * p + (n / b) * q;
            for (int i = 1; i <= n / b; i++)
                if ((b * i) % a == 0)
                {
                    nok = b * i;
                    break;
                }
            if (nok != 0)
                if (p > q)
                {
                    answer -= (n / nok) * q;
                }
                else
                {
                    answer -= (n / nok) * p;
                }
            Console.WriteLine(answer);
        }
    }
}


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

namespace ConsoleApplication1
{
	class Program
	{
		static void Main(string[] args)
		{
			try
			{
				Main main = new Main();
				main.ReadData();
				main.Process();
				main.WriteAnswer();
			}
			catch (Exception e)
			{
				Console.WriteLine(e);
			}
		}
	}

	class Main
	{
		private long _result;
		private long _n;
		private long _a;
		private long _b;
		private long _p;
		private long _q;

		public void Process()
		{
			long min = Math.Min(_p, _q);

			long la = _n / _a;
			long sa = la*_p;

			long lb = _n / _b;
			long sb = lb * _q;

			_result = sb + sa;

			long step = Math.Max(_a, _b);
			int i = 0;
			while (true)
			{
				i++;
				long j = step*i;
				if (j <= _n)
				{
					if (j%_a == 0 && j%_b == 0)
					{
						_result -= (min);
					}
				}
				else
				{
					break;
				}
			}

			//_result = _y;
		}

		public void ReadData()
		{
			TextReader textReader = Console.In;
			//TextReader textReader = new StreamReader("input.txt");
			using (TextReader reader = textReader)
			{
				string readLine = reader.ReadLine();
				string[] strings = readLine.Split(' ');

				_n = long.Parse(strings[0]);
				_a = long.Parse(strings[1]);
				_b = long.Parse(strings[2]);
				_p = long.Parse(strings[3]);
				_q = long.Parse(strings[4]);

			}
		}

		public void WriteAnswer()
		{
			using (TextWriter writer = Console.Out)
			{
				writer.WriteLine(_result);
			}
		}
	}
}


/*C. Несправедливый опрос

На уроке литературы Серёжа заметил чудовищную несправедливость, ему кажется, что некоторых учеников спрашивают чаще чем других.

Рассадка в классе представляет собой прямоугольник, в котором n рядов по m учащихся в каждом.

Учительница опрашивает учеников в следующем порядке: сначала она спрашивает всех учеников с первого
 ряда в порядке их рассадки на ряду, после опроса всех учеников на очередном ряду она переходит к следующему,
 по порядку следования опроса, ряду. Если учительница опросила последний ряд, то направление опроса сменяется,
 то есть опрашивается предыдущий ряд. Порядок опроса рядов выглядит следующим образом:
 1-й ряд, 2-й ряд, ..., n - 1-й ряд, n-й ряд, n - 1-й ряд, ..., 2-й ряд, 1-й ряд, 2-й ряд, ...

Порядок опроса учеников на одном ряду всегда один и тот же: 1-й ученик, 2-й ученик, ..., m-й ученик.

За урок учительница успела опросить ровно k вопросов у учеников в порядке описанном выше.
 Серёжа сидит в x-м ряду, на y-м по порядку месте. Сергей решил доказать учителю,
 что ученики опрашиваются неравномерно, помогите ему вычислить три величины:

максимальное количество вопросов, заданных одному из учеников,
минимальное количество вопросов, заданных одному из учеников,
сколько раз учительница спросила Серёжу.
Если в классе только один ряд, то учительница всегда опрашивает детей с него.

Входные данные
Первая и единственная строка содержит пять целых чисел n, m, k, x и y (1 ≤ n, m ≤ 100, 1 ≤ k ≤ 1018, 1 ≤ x ≤ n, 1 ≤ y ≤ m).

Выходные данные
Выведите три числа:

максимальное количество вопросов, заданных одному из учеников,
минимальное количество вопросов, заданных одному из учеников,
сколько раз учительница спросила Серёжу.*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace NespravedliviyOpros758C
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("Введите количество рядов: ");
            int n = int.Parse(Console.ReadLine());

            Console.Write("Введите количество учащихся в ряде: ");
            int m = int.Parse(Console.ReadLine());

            Console.Write("Введите количество вопросов: ");
            long k = long.Parse(Console.ReadLine());

            Console.Write("В каком ряду сидит Сережа: ");
            int x = int.Parse(Console.ReadLine());

            Console.Write("На каком по порядку месте сидит Сережа: ");
            int y = int.Parse(Console.ReadLine());

            //Создаем массив
            int[,] r = new int[n, m];

            int kol=0,p=1,i=0,j=0;

            //Если всего 1 ряд, то i не будет изменяться (i+p == i) не меняется
            if (n==1) {p=0;}

            //Прогоняем ситуацию в цикле
            do
            {
             j=0; //ряды
             do
             {
                 r[i, j] += 1;//задали вопрос
                 kol += 1;//количество вопросов заданных вопросов изменилосьт на 1
                 j += 1;
             } while (kol != k && j != m); //Цикл продолжается пока количество вопросов не равно к и не опрошены все ученики в данном ряду.
            i+=p;
            if (i==n-1) {p*=-1;} // Если последний ряд, то идем в обратную сторону
            if (i == 0) { p *= -1; } // Если вернулись на первый ряд опять меняем направление
            } while (kol!=k);

            int max = r[0,0]; //Максимальное количество вопросов, заданных одному ученику.
            int min = r[0,0];//Минимальное количество вопросов, заданных одному ученику.

            //Проверяем у какого ученика меньше всего и больше всего вопросов

            for (i=0; i<n; i++)
            {
                for (j = 0; j < m; j++)
                {
                    if (r[i, j] > max) {max=r[i,j] ;}
                    if (r[i, j] < min) { min = r[i, j]; }
                }

            }

            Console.WriteLine("Максимальнок количество вопросов {0}", max);

            Console.WriteLine("Минимальное количество вопросов {0}", min);

            Console.WriteLine("Учительница спросила сережу {0} раз", r[x-1,y-1]);
            Console.ReadLine();
        }
    }
}


/*C. Несправедливый опрос

На уроке литературы Серёжа заметил чудовищную несправедливость, ему кажется, что некоторых учеников спрашивают чаще чем других.

Рассадка в классе представляет собой прямоугольник, в котором n рядов по m учащихся в каждом.

Учительница опрашивает учеников в следующем порядке: сначала она спрашивает всех учеников с первого
 ряда в порядке их рассадки на ряду, после опроса всех учеников на очередном ряду она переходит к следующему,
 по порядку следования опроса, ряду. Если учительница опросила последний ряд, то направление опроса сменяется,
 то есть опрашивается предыдущий ряд. Порядок опроса рядов выглядит следующим образом:
 1-й ряд, 2-й ряд, ..., n - 1-й ряд, n-й ряд, n - 1-й ряд, ..., 2-й ряд, 1-й ряд, 2-й ряд, ...

Порядок опроса учеников на одном ряду всегда один и тот же: 1-й ученик, 2-й ученик, ..., m-й ученик.

За урок учительница успела опросить ровно k вопросов у учеников в порядке описанном выше.
 Серёжа сидит в x-м ряду, на y-м по порядку месте. Сергей решил доказать учителю,
 что ученики опрашиваются неравномерно, помогите ему вычислить три величины:

максимальное количество вопросов, заданных одному из учеников,
минимальное количество вопросов, заданных одному из учеников,
сколько раз учительница спросила Серёжу.
Если в классе только один ряд, то учительница всегда опрашивает детей с него.

Входные данные
Первая и единственная строка содержит пять целых чисел n, m, k, x и y (1 ≤ n, m ≤ 100, 1 ≤ k ≤ 1018, 1 ≤ x ≤ n, 1 ≤ y ≤ m).

Выходные данные
Выведите три числа:

максимальное количество вопросов, заданных одному из учеников,
минимальное количество вопросов, заданных одному из учеников,
сколько раз учительница спросила Серёжу.*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace NespravedliviyOpros758C
{
    class Program
    {
        static void Main(string[] args)
        {
            string vh = Console.ReadLine();
            string[] t = vh.Split(' ');

            int n = int.Parse(t[0]);

            int m = int.Parse(t[1]);

            //Введите количество вопросов:
            long k = long.Parse(t[2]);

            //В каком ряду сидит Сережа:
            int x = int.Parse(t[3]);

            //На каком по порядку месте сидит Сережа:
            int y = int.Parse(t[4]);

            //Создаем массив
            int[,] r = new int[n, m];

            int kol=0,p=1,i=0,j=0;

            //Если всего 1 ряд, то i не будет изменяться (i+p == i) не меняется
            if (n==1) {p=0;}

            //Прогоняем ситуацию в цикле
            do
            {
             j=0; //ряды
             do
             {
                 r[i, j] += 1;//задали вопрос
                 kol += 1;//количество вопросов заданных вопросов изменилосьт на 1
                 j += 1;
             } while (kol != k && j != m); //Цикл продолжается пока количество вопросов не равно к и не опрошены все ученики в данном ряду.
            i+=p;
            if (i==n-1) {p*=-1;} // Если последний ряд, то идем в обратную сторону
            if (i == 0) { p *= -1; } // Если вернулись на первый ряд опять меняем направление
            } while (kol!=k);

            int max = r[0,0]; //Максимальное количество вопросов, заданных одному ученику.
            int min = r[0,0];//Минимальное количество вопросов, заданных одному ученику.

            //Проверяем у какого ученика меньше всего и больше всего вопросов

            for (i=0; i<n; i++)
            {
                for (j = 0; j < m; j++)
                {
                    if (r[i, j] > max) {max=r[i,j] ;}
                    if (r[i, j] < min) { min = r[i, j]; }
                }

            }

            Console.WriteLine("{0} {1} {2}", max, min, r[x-1,y-1]);

        }
    }
}


//#define FILE_INPUT
using System;
using System.Collections.Generic;
using System.Text;
//using System.Text.RegularExpressions;
using System.Linq;
//using System.Collections;
//using System.Collections.Specialized;
//using System.Numerics;

//94A. Восстановление пароля

namespace CodeForces
{

    class Solution
    {
        static void Main()
        {
            new Solution().solve();
            Pause();
        }

        void solve()
        {
            string s = cin.Line();
            Dictionary<string, int> m = new Dictionary<string, int>();

            for (int i = 0; i < 10; i++)
            {
                m.Add(cin.Line(), i);
            }

            for (int i = 0; i < 8; i++)
            {
                Console.Write(m[s.Substring(i, 10)]);
            }

            Console.WriteLine();
        }

        #region Tools

        [System.Diagnostics.Conditional("DEBUG")]
        static private void DebugOut<T>(string format, T arg)
        {
            Console.WriteLine(format, arg);
        }

        [System.Diagnostics.Conditional("DEBUG")]
        static private void DebugOut(string format, params object[] arg)
        {
            Console.WriteLine(format, arg);
        }

        [System.Diagnostics.Conditional("DEBUG")]
        static private void DebugStop()
        {
            Console.ReadKey(true);
        }

        private static T[] ga<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;
        }

        private static T[] ga<T>(int n, Func<T> f)
        {
            var a = new T[n];
            for (int i = 0; i < n; ++i) a[i] = f();
            return a;
        }

        private static int gi()
        { return cin.gi(); }

        private static List<T> gl<T>(int n, Func<int, T> f)
        {
            var a = new List<T>(n + 1);
            for (int i = 0; i < n; ++i) a.Add(f(i));
            return a;
        }

        [System.Diagnostics.Conditional("DEBUG")]
        static private void Pause()
        {
            Console.WriteLine("[debug]");
            Console.ReadKey(true);
        }
        private static void swap<T>(ref T a, ref T b)
        {
            T t = a; a = b; b = t;
        }

        #endregion Tools
    }

    class cin
    {
        public static int error { get; set; }

        static cin()
        {
#if (ONLINE_JUDGE || !FILE_INPUT)
                reader = new System.IO.BufferedStream(Console.OpenStandardInput(1024 * 10), 1024 * 10);
#else
            reader = new System.IO.BufferedStream((new System.IO.StreamReader("input.txt")).BaseStream, 1024 * 16);
#endif
        }

        public static System.IO.BufferedStream reader { get; private set; }
        public static char Char() { return (char)reader.ReadByte(); }

        public static int gi()
        {
            for (int c = read(); c != -1; c = read())
            {
                switch ((char)c)
                {
                    case '-':
                        return -(int)gu(read());

                    default:
                        if (char.IsDigit((char)c)) return (int)gu(c);
                        break;
                }
            }

            throw new System.IO.IOException();
        }

        public static uint gu()
        {
            return gu(read());
        }

        public static string Line()
        {
            int c;
            StringBuilder sb = new StringBuilder();
            for (c = read(); c != 10; c = read()) sb.Append((char)c);
            if (sb.Length > 0 && sb[sb.Length - 1] == 13) sb.Length -= 1;
            return sb.ToString();
        }

        public static int rawLine(byte[] a, int offset = 0)
        {
            int c, i = offset;
            for (c = reader.ReadByte(); c != 10; c = reader.ReadByte()) a[i++] = (byte)c;
            if (i > 0 && a[i - 1] == 13) i--;
            return i - offset;
        }

        public static int rawLine(char[] a, int offset = 0)
        {
            Array.ConvertAll(a, Convert.ToInt16);

            int c, i = offset;
            for (c = read(); c != 10 && c != -1; c = read()) a[i++] = (char)c;
            if (i > 0 && a[i - 1] == 13) i--;
            return i;
        }

        public static int rawLine<T>(T[] a, Func<int, T> converter) where T : IComparable<int>
        {
            int c, i = 0;
            for (c = read(); c != 10; c = read()) a[i++] = converter(c);
            if (i > 0 && a[i - 1].CompareTo(13) == 0) i--;
            return i;
        }

        public static string Scan()
        {
            int c;
            StringBuilder sb = new StringBuilder();
            do c = read(); while (c < 33 || c > 126);
            for (; c >= 33 && c <= 126; c = read()) sb.Append((char)c);
            return sb.ToString();
        }
        public static void Scan(Action<int> f)
        {
            int c;
            StringBuilder sb = new StringBuilder();
            do c = read(); while (c < 33 || c > 126);
            for (; c >= 33 && c <= 126; c = read()) f(c);
        }

        private static uint gu(int first)
        {
            int c;
            uint u = (uint)first - '0';
            for (c = read(); c != -1 && char.IsDigit((char)c); c = read())
            {
                u = 10 * u + (uint)c - '0';
            }

            error = c;
            return u;
        }

        private static int read() { return reader.ReadByte(); }

        public static bool NewLine()
        {
            int c = error;
            if (c != 10) do c = reader.ReadByte(); while (c != -1 && c != 10);
            return c != -1;
        }
    }
}


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

namespace Codeforces
{
    class E
    {
        private static ThreadStart  s_threadStart = new E().Go;

        class Point
        {
            public int X, Y;
            public bool Keep;
        }

        private void Go()
        {
            long mod = 1000000007;

            int n = GetInt();
            Point[] points = new Point[n];
            for (int i = 0; i < n; i++)
            {
                points[i] = new Point() { X = GetInt(), Y = GetInt() };
            }

            Dictionary<int, List<int>> xDict = new Dictionary<int, List<int>>();
            Dictionary<int, List<int>> yDict = new Dictionary<int, List<int>>();
            for(int i = 0; i < n; i++)
            {
                List<int> list;
                if (!xDict.TryGetValue(points[i].X, out list))
                    list = xDict[points[i].X] = new List<int>();

                list.Add(i);

                if (!yDict.TryGetValue(points[i].Y, out list))
                    list = yDict[points[i].Y] = new List<int>();

                list.Add(i);
            }

            long ans = 1;

            int k = n;
            for (int i = 0; i < n; i++)
            {
                if (xDict[points[i].X].Count == 1 && yDict[points[i].Y].Count == 1)
                {
                    ans *= 3;
                    ans %= mod;
                    xDict.Remove(points[i].X);
                    yDict.Remove(points[i].Y);
                    k--;
                }
            }

            int m = xDict.Count() + yDict.Count();

            ans *= Bin(m, k, mod);
            ans %= mod;
            Wl(ans);
        }

        long Bin(long n, long k, long mod)
        {
            if (n < 2) return 1;

            long[] bin = new long[k + 1]; bin[0] = 1; bin[1] = 1;
            long[] next = new long[k + 1];
            long[] t;

            for (int i = 2; i <= k; i++)
            {
                next[0] = 1; next[i] = 1;
                for (int j = 1; j <= k && j < i; j++)
                    next[j] = (bin[j] + bin[j - 1]) % mod;

                t = bin;
                bin = next;
                next = t;
            }

            long ans = 0;
            for (int i = 0; i <= k; i++)
            {
                ans += bin[i];
                ans %= mod;
            }
            return ans;
        }

        #region Template

        private static StringBuilder output = new StringBuilder();

        public static void Main(string[] args)
        {
            System.Diagnostics.Stopwatch timer = new System.Diagnostics.Stopwatch();
            output.Length = 0;
            Thread main = new Thread(new ThreadStart(s_threadStart), 512 * 1024 * 1024);
            timer.Start();
            main.Start();
            main.Join();
            Console.Write(output);
            timer.Stop();
            Console.Error.WriteLine(timer.ElapsedMilliseconds);
        }

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

            return ioEnum.Current;
        }

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

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

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

        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)
        {
            W(o);
            output.Append(Console.Out.NewLine);
        }

        private static void Wl<T>(IEnumerable<T> enumerable)
        {
            W(enumerable);
            output.Append(Console.Out.NewLine);
        }

        private static void W<T>(T o)
        {
            if (o is double)
            {
                Wd((o as double?).Value, "");
            }
            else if (o is float)
            {
                Wd((o as float?).Value, "");
            }
            else
                output.Append(o.ToString());
        }

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

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

        #endregion
    }
}