The princess is going to escape the dragon's cave, and she needs to plan it carefully.The princess runs at vp miles per hour, and the dragon flies at vd miles per hour. The dragon will discover the escape after t hours and will chase the princess immediately. Looks like there's no chance to success, but the princess noticed that the dragon is very greedy and not too smart. To delay him, the princess decides to borrow a couple of bijous from his treasury. Once the dragon overtakes the princess, she will drop one bijou to distract him. In this case he will stop, pick up the item, return to the cave and spend f hours to straighten the things out in the treasury. Only after this will he resume the chase again from the very beginning.The princess is going to run on the straight. The distance between the cave and the king's castle she's aiming for is c miles. How many bijous will she need to take from the treasury to be able to reach the castle? If the dragon overtakes the princess at exactly the same moment she has reached the castle, we assume that she reached the castle before the dragon reached her, and doesn't need an extra bijou to hold him off.

The input data contains integers vp, vd, t, f and c, one per line (1 ≤ vp, vd ≤ 100, 1 ≤ t, f ≤ 10, 1 ≤ c ≤ 1000).

Output the minimal number of bijous required for the escape to succeed.

NoteIn the first case one hour after the escape the dragon will discover it, and the princess will be 1 mile away from the cave. In two hours the dragon will overtake the princess 2 miles away from the cave, and she will need to drop the first bijou. Return to the cave and fixing the treasury will take the dragon two more hours; meanwhile the princess will be 4 miles away from the cave. Next time the dragon will overtake the princess 8 miles away from the cave, and she will need the second bijou, but after this she will reach the castle without any further trouble.The second case is similar to the first one, but the second time the dragon overtakes the princess when she has reached the castle, and she won't need the second bijou.

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

namespace _105b
{
    class Program
    {
        class Scanner
        {
            string[] s;
            int i;

            char[] cs = new char[] { ' ' };

            public Scanner()
            {
                s = new string[0];
                i = 0;
            }

            public string next()
            {
                if (i < s.Length) return s[i++];
                s = Console.ReadLine().Split(cs, StringSplitOptions.RemoveEmptyEntries);
                i = 0;
                return s[i++];
            }

            public int nextInt()
            {
                return int.Parse(next());
            }

            public double nextDouble()
            {
                return (double)nextInt();
            }

            public long nextLong()
            {
                return long.Parse(next());
            }

        }
        static void Main(string[] args)
        {
            Scanner sc = new Scanner();
            double vp = sc.nextDouble();
            double vd = sc.nextDouble();
            double t = sc.nextDouble();
            double f = sc.nextDouble();
            double c = sc.nextDouble();
            if (vp >= vd)
            {
                Console.WriteLine(0);
                return;
            }
            int count = 0;
            double H;
            double t0;
            H = vp * t;
            while (true)
            {
                t0 = H / (vd - vp);

                H += vp * t0;

                if (H >= (double)c)
                {
                    Console.WriteLine(count);
                    return;
                }
                else
                {
                    count++;
                    t0 = (H / vd) + f;
                    H += vp * t0;
                }
            }

        }
    }
}

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

namespace Codeforces
{
    internal class Program
    {
        private static string Read()
        {
            return Console.ReadLine();
        }
        private static string[] ReadArray()
        {
            return Console.ReadLine().Split(' ');
        }
        private static int ReadInt()
        {
            return Int32.Parse(Console.ReadLine());
        }
        private static long ReadLong()
        {
            return long.Parse(Console.ReadLine());
        }
        private static int ReadNextInt(string[] input, int index)
        {
            return Int32.Parse(input[index]);
        }

        private static void Main()
        {
            var vp = ReadInt();
            var vd = ReadInt();
            var t = ReadInt();
            var f = ReadInt();
            var c = ReadInt();
            var res = 0;
            var curT = (float)t;
            if(vp >= vd)
            {
                Console.WriteLine(0);
                return;
            }
            while (true)
            {
                var time = (float) curT*vp/(vd - vp);

                var dist = (curT + time)*vp;
                if(dist >=c)
                    break;

                res++;
                curT += time + dist/vd + f;
            }
            Console.WriteLine(res);
        }

    }
}

using System;

namespace testOlymp
{
    class Program
    {
        static void Main(string[] args)
        {
            double w = int.Parse(Console.ReadLine());
            double v = int.Parse(Console.ReadLine());
            double t = int.Parse(Console.ReadLine());
            double f = int.Parse(Console.ReadLine());
            double c = int.Parse(Console.ReadLine());

            int count = 0;
            if (v > w)
            {
                for (double s = t * w * (1.0 + v / (v - w)); s < c; s += t * w)
                {
                    count++;
                    t = s / v + f + s / (v - w);
                }
            }
            Console.Write(count);
        }
    }
}

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

namespace ConsoleApplication1
{
  class Program
  {

    static void Main(string[] args)
    {
      int vp = int.Parse(Console.ReadLine());
      int vd = int.Parse(Console.ReadLine());
      int t = int.Parse(Console.ReadLine());
      int f = int.Parse(Console.ReadLine());
      int c = int.Parse(Console.ReadLine());

      if (vp >= vd)
      {
        Console.WriteLine(0);
        return;
      }

      float posp = vp * t;
      float posd = 0;

      int res = 0;

      while (posp < c)
      {
        posp = posp + vp * (posp / (vd - vp));
        if (posp < c) res++;
        posp += vp * (f + posp / vd);
      }

      Console.WriteLine(res);

    }
  }
}

using System;

class Program
{
    static void Main(string[] args)
    {
        double vp = Convert.ToDouble(Console.ReadLine());
        double vd = Convert.ToDouble(Console.ReadLine());
        double t = Convert.ToDouble(Console.ReadLine());
        double f = Convert.ToDouble(Console.ReadLine());
        double c = Convert.ToDouble(Console.ReadLine());
        double put = t * vp;
        if(vp>=vd)
        {
            Console.WriteLine(0);
            return;
        }
        double otr = put;
        double prom;
        int dr = 0;
        //int dput = 0;
        while (put < c)
        {
            prom = vd - vp;
            prom = put / prom;
            prom = prom * vp;
            put += prom;
            if (put >= c)
            {
                Console.WriteLine(dr);
                //Console.ReadKey();
                return;
            }
            else
            {
                dr++;
                prom = put / vd;
                prom = vp * prom;
                put += prom;
                prom = vp * f;
                put += prom;
                otr = put;
            }
        }
    Console.WriteLine(dr);
    //Console.ReadKey();
    return;

    }
}

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

    class Program
    {
        static void Main(string[] args)
        {
            string g = f();
            Console.WriteLine(g);
            Console.ReadLine();

        }

        public static string f()
        {
            int vp = int.Parse(Console.ReadLine());
            int vd = int.Parse(Console.ReadLine());
            int t = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            float t1 = t;
            float t2 = 0;
            int tp = 0;
            if (vd < vp)
            {
                return "0";
            }
            for (int i = 1; i < 1000; i++)
            {
                t2 = Math.Abs((vp*t1) / (vd - vp));
                if ((vp * t2+vp*t1) >= c)
                {
                    return tp.ToString();
                }
                tp=tp+1;
                t1 = t1 + t2 + f + t2;
            }
            return "";
        }
    }

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

namespace J
{
    class Program
    {
        static void Main(string[] args)
        {
            int vp = Convert.ToInt32(Console.ReadLine());
            int vd = Convert.ToInt32(Console.ReadLine());
            int t = Convert.ToInt32(Console.ReadLine());
            int f = Convert.ToInt32(Console.ReadLine());
            int c = Convert.ToInt32(Console.ReadLine());
            double l = c - t * vp;
            double ft = ((double)c / vp) - t;
            int s = 0;
            double tempt;
            if (vp > vd)
            {
                Console.WriteLine(0);
            }
            else
            {
                while (true)
                {
                    tempt = (double)(c - l) / (vd - vp);
                    ft -= tempt;
                    if (ft > 0)
                    {
                        s++;
                    }
                    l = l - (2 * tempt + f) * vp;
                    ft -= tempt;
                    ft -= f;
                    if (ft <= 0)
                    {
                        break;
                    }

                }
                Console.WriteLine(s);
            }

        }
    }
}

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

namespace B
{
    class Program
    {
        static void Main(string[] args)
        {
            int vp = int.Parse(Console.ReadLine().Trim());
            int vd = int.Parse(Console.ReadLine().Trim());
            int late = int.Parse(Console.ReadLine().Trim());
            int wait = int.Parse(Console.ReadLine().Trim());
            int distance = int.Parse(Console.ReadLine().Trim());

            double p = vp * late;
            int drag = 0;

            if (vp > vd)
            {
                Console.WriteLine(0);
                return;
            }

            while (p < distance)
            {
                double time1 = p;
                time1 /= (vd - vp);

                double delta = time1 * vp;

                p += delta;

                if (p >= distance)
                {
                    break;
                }

                ++drag;

                double time2 = p;
                time2 /= vd;

                time2 += wait;

                double delta2 = time2 * vp;
                p += delta2;
            }

            Console.WriteLine(drag);
        }
    }
}

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

namespace Task
{
    #region MyIo

    class MyIo : IDisposable
    {
        private readonly TextReader inputStream;
        private readonly TextWriter outputStream = Console.Out;

        string[] tokens;
        int pointer;

        public MyIo()
#if  LOCAL_TEST
            : this(new StreamReader("input.txt"))
#else
            : this(System.Console.In)
#endif
        {

        }

        public MyIo(TextReader inputStream)
        {
            this.inputStream = inputStream;
        }

        public string NextLine()
        {
            try
            {
                return inputStream.ReadLine();
            }
            catch (IOException)
            {
                return null;
            }
        }

        public string NextString()
        {
            try
            {
                while (tokens == null || pointer >= tokens.Length)
                {
                    tokens = NextLine().Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
                    pointer = 0;
                }
                return tokens[pointer++];
            }
            catch (IOException)
            {
                return null;
            }
        }

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

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

        public void Print(string format, params object[] args)
        {
            outputStream.Write(string.Format(CultureInfo.InvariantCulture, format, args));
        }

        public void PrintLine(string format, params object[] args)
        {
            Print(format, args);

            outputStream.WriteLine();
        }

        public void Print<T>(T o)
        {
            outputStream.Write(o);
        }

        public void PrintLine<T>(T o)
        {
            outputStream.WriteLine(o);
        }

        public void Close()
        {
            inputStream.Close();
            outputStream.Close();
        }

        void IDisposable.Dispose()
        {
            Close();

#if  LOCAL_TEST
            Console.ReadLine();
#endif
        }
    }
    #endregion

    class Program
    {
        #region Program

        readonly MyIo io;

        public Program(MyIo io)
        {
            this.io = io;
        }

        static void Main(string[] args)
        {
            using (MyIo io = new MyIo())
            {
                new Program(io)
                    .Solve();
            }
        }

        #endregion

        void Solve()
        {
            var vp = (double)io.NextInt();
            var vd = (double)io.NextInt();
            var t = (double)io.NextInt();
            var f = (double)io.NextInt();
            var c = (double)io.NextInt();

            int res = 0;

            var x = 0.0;
            if (vp < vd)
            {

                while (c - x> 0)
                {
                    x += (vp / (vd - vp) + 1.0) * t * vp;
                    t = 2.0 * x / vd + f;

                    if (c - x > 0)
                        res++;
                }
            }

            io.Print(res);
        }

    }
}

#define Online

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

delegate double F(double x);
delegate decimal Fdec(decimal x);

class Edge
{
    public int a;
    public int b;
    public int w;

    public Edge(int a, int b, int w)
    {
        this.a = a;
        this.b = b;
        this.w = w;
    }
}

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

        Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;

#if FileIO
        StreamReader sr = new StreamReader("forest.in");
        StreamWriter sw = new StreamWriter("forest.out");
        Console.SetIn(sr);
        Console.SetOut(sw);
#endif

        double vp, vd, t, f, c;
        vp = double.Parse(Console.ReadLine());
        vd = double.Parse(Console.ReadLine());
        t = double.Parse(Console.ReadLine());
        f = double.Parse(Console.ReadLine());
        c = double.Parse(Console.ReadLine());
        if (vp >= vd)
        {
            Console.WriteLine(0);
            return;
        }
        int ans = 0;
        double s = vp * t;
        double tt;
        double back_dist;
        while (s < c)
        {
            tt = s / (vd - vp);
            s += tt * vp;
            if (s < c) ans++;
            back_dist = tt * vd;
            s += vp * (back_dist / vd);
            s += f * vp;
        }
        Console.WriteLine(ans);

#if Online
        Console.ReadLine();
#endif

#if FileIO
        sr.Close();
        sw.Close();
#endif
    }

    static string[] ReadArray()
    {
        return Console.ReadLine().Split(' ');
    }

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

    static decimal Sqrt(decimal x)
    {
        decimal mid;
        decimal right = (x <= 1 ? 1 : x);
        decimal left = 0;
        decimal eps = 0.00000000000000000001m;
        while (right - left > eps)
        {
            mid = left + ((right - left) / 2m);
            if (Math.Sign(mid * mid - x) != Math.Sign(left * left - x))
                right = mid;
            else
                left = mid;
        }
        return (left + right) / 2m;
    }

    public static  int[] FordBellman(int n, int v, Edge[] e)
    {
        int[] d = new int[n + 1];
        for (int i = 1; i <= n; i++)
            d[i] = int.MaxValue;
        d[v] = 0;
        for (int i = 1; i < n; i++)
        {
            for (int j = 0; j < e.Length; j++)
            {
                if (d[e[j].a] != int.MaxValue)
                {
                    if (d[e[j].b] > d[e[j].a] + e[j].w)
                    {
                        d[e[j].b] = d[e[j].a] + e[j].w;
                    }
                }
            }
        }
        return d;
    }

}

static class ArrayUtils
{
    public static int BinarySearch(int[] a, int val)
    {
        int left = 0;
        int right = a.Length - 1;
        int mid;

        while (left < right)
        {
            mid = left + ((right - left) >> 1);
            if (val <= a[mid])
            {
                right = mid;
            }
            else
            {
                left = mid + 1;
            }
        }

        if (a[left] == val)
            return left;
        else
            return -1;
    }

    public static double Bisection(F f, double left, double right, double eps)
    {
        double mid;
        while (right - left > eps)
        {
            mid = left + ((right - left) / 2d);
            if (Math.Sign(f(mid)) != Math.Sign(f(left)))
                right = mid;
            else
                left = mid;
        }
        return (left + right) / 2d;
    }

    public static decimal TernarySearchDec(Fdec f, decimal eps, decimal l, decimal r, bool isMax)
    {
        decimal m1, m2;
        while (r - l > eps)
        {
            m1 = l + (r - l) / 3m;
            m2 = r - (r - l) / 3m;
            if (f(m1) < f(m2))
                if (isMax)
                    l = m1;
                else
                    r = m2;
            else
                if (isMax)
                    r = m2;
                else
                    l = m1;
        }
        return r;
    }

    public static double TernarySearch(F f, double eps, double l, double r, bool isMax)
    {
        double m1, m2;
        while (r - l > eps)
        {
            m1 = l + (r - l) / 3d;
            m2 = r - (r - l) / 3d;
            if (f(m1) < f(m2))
                if (isMax)
                    l = m1;
                else
                    r = m2;
            else
                if (isMax)
                    r = m2;
                else
                    l = m1;
        }
        return r;
    }

    public static void Merge(int[] A, int p, int q, int r, int[] L, int[] R)
    {
        for (int i = p; i <= q; i++)
            L[i] = A[i];
        for (int i = q + 1; i <= r; i++)
            R[i] = A[i];

        for (int k = p, i = p, j = q + 1; k <= r; k++)
        {
            if (i > q)
            {
                for (; k <= r; k++, j++)
                    A[k] = R[j];
                return;
            }
            if (j > r)
            {
                for (; k <= r; k++, i++)
                    A[k] = L[i];
                return;
            }
            if (L[i] <= R[j])
            {
                A[k] = L[i];
                i++;
            }
            else
            {
                A[k] = R[j];
                j++;
            }
        }
    }

    public static void Merge_Sort(int[] A, int p, int r, int[] L, int[] R)
    {
        if (!(p < r)) return;
        int q = p + ((r - p) >> 1);
        Merge_Sort(A, p, q, L, R);
        Merge_Sort(A, q + 1, r, L, R);
        Merge(A, p, q, r, L, R);
    }
}

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

namespace CF105
{
    // B
    class Escape
    {
        static void Main(string[] args)
        {
            int vp = int.Parse(Console.ReadLine());
            int vd = int.Parse(Console.ReadLine());
            int t = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());

            if (vp >= vd)
            {
                Console.WriteLine(0);
                return;
            }

            int bijous = 0;
            float xp = t * vp;
            float xd = 0;
            bool chasing = true;
            while (xp < c)
            {
                //Console.WriteLine(String.Format("xp={0}, xd={1}", xp, xd));
                // If they meet this step
                if (chasing && (xp - xd) < (vd - vp))
                {
                    float timeToMeet = (xd - xp) / (vp - vd);
                    xd += timeToMeet * vd;
                    xp += timeToMeet * vp;
                    bijous++;
                    chasing = false;
                }
                // If dragon gets back this step
                else if (!chasing && xd <= vd)
                {
                    float timeToGetBack = xd / vd;
                    xd = 0;
                    xp += (timeToGetBack + f) * vp;
                    chasing = true;
                }
                // Normal move turn
                else
                {
                    xp += vp;

                    if (chasing)
                        xd += vd;
                    else
                        xd -= vd;
                }
            }

            Console.WriteLine(bijous);
            //Console.Read();
        }
    }
}

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

namespace Codeforces
{
    class B
    {
        private static object Go()
        {
            int vp = GetInt();
            int vd = GetInt();
            int t = GetInt();
            int f = GetInt();
            int c = GetInt();

            if (vd <= vp) return 0;

            double curr = vp * t;
            int ret = 0;
            while (curr < c)
            {
                double time = curr / (vd - vp);
                curr += time * vp;
                if (curr >= c) return ret;
                ret++;
                curr += (time + f) * vp;
            }

            return ret;
        }

        #region Template

        public static void Main(string[] args)
        {
            object output = Go();
            if (output != null)
                Wl<string>(output.ToString());
        }

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

            return ioEnum.Current;
        }

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

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

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

        private static void Wl<T>(T o)
        {
            Console.WriteLine(o.ToString());
        }

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

        public struct Tuple<T, K>
        {
            public T Item1;
            public K Item2;

            public Tuple(T t, K k)
            {
                Item1 = t;
                Item2 = k;
            }

            public override bool Equals(object obj)
            {
                var o = (Tuple<T, K>)obj;
                return o.Item1.Equals(Item1) && o.Item2.Equals(Item2);
            }

            public override int GetHashCode()
            {
                return Item1.GetHashCode() ^ Item2.GetHashCode();
            }

            public override string ToString()
            {
                return "(" + Item1 + " " + Item2 + ")";
            }
        }

        #endregion
    }
}

using System;
using System.Linq;

namespace olimpP
{
	class MainClass
	{
		public static void Main (string[] args)
		{

			int a = Convert.ToInt32 (Console.ReadLine());
			int b = Convert.ToInt32 (Console.ReadLine());
			int c = Convert.ToInt32 (Console.ReadLine());
			int d = Convert.ToInt32 (Console.ReadLine());
			int e = Convert.ToInt32 (Console.ReadLine());

			Console.WriteLine(Func4 (a,b,c,d,e));

		}

		public static int Func4(int vs, int vp, double tf, int td, int c)
		{
			if (vs > vp)
				return 0;
			int count = 0;
			int time = c/vs;
			double time1 = 0;
			while (time1 < time){
				time1 = (vp*tf) / ((vp - vs));
				tf = time1 - tf + td+ time1;
				if (time1 < time)
					count++;
			}
			return count;
		}
	}
}

using System;

namespace CodeforcesSolution
{
    public class Escape
    {
        public static void Main(string[] args)
        {
            int vp, vd, t, f, c;
            vp = int.Parse(Console.ReadLine());
            vd = int.Parse(Console.ReadLine());
            t = int.Parse(Console.ReadLine());
            f = int.Parse(Console.ReadLine());
            c = int.Parse(Console.ReadLine());
            int count = 0;
            if (vp < vd)
            {
                float pp = t * vp;
                while (pp < c)
                {
                    float hour = (float)pp/(vd - vp);
                    if (pp + (hour * vp) >= c)
                    {
                        break;
                    }
                    count++;
                    pp += hour*vp;
                    float hourd = (pp/vd) + f;
                    pp += hourd*vp;

                }
            }
            Console.WriteLine(count);
        }
    }
}

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

namespace TaskA
{
    class Program
    {
        static void Main(string[] args)
        {
            const double eps = 0.0000001;
            int vp, vd, t, f, c, res = 0;
            double tt, td;
            vp = int.Parse(Console.ReadLine());
            vd = int.Parse(Console.ReadLine());
            t = int.Parse(Console.ReadLine());
            f = int.Parse(Console.ReadLine());
            c = int.Parse(Console.ReadLine());
            if (vp >= vd)
            {
                Console.WriteLine(res);
                return;
            }
            tt = (vd * t) / (vd - vp);
            while (!(vp * tt > c - eps))
            {
                res++;
                td = tt + (vp * tt) / vd + f;
                tt = (vd * td) / (vd - vp);
            }
            Console.WriteLine(res);
        }
    }
}

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

namespace CF105D2B
{
    class CF105D2B
    {
        public static void Main(string[] args)
        {
            EasyScanner sc = new EasyScanner(Console.In);
            double vp = sc.NextInt();
            double vd = sc.NextInt();
            double t = sc.NextInt();
            double f = sc.NextInt();
            double c = sc.NextInt();

            if (vp >= vd)
            {
                Console.Out.WriteLine(0);
                return;
            }

            double x = vp * t;
            x += vp * (x / (vd - vp));

            int count = 0;
            while (x < c)
            {
                count++;
                x += vp * (x / vd);
                x += vp * f;
                x += vp * (x / (vd - vp));
            }
            Console.Out.WriteLine(count);
        }
    }

    class EasyScanner
    {
        private TextReader reader;
        private Queue<string> tokens;

        public EasyScanner(TextReader reader)
        {
            this.reader = reader;
            this.tokens = new Queue<string>();
        }

        private void MaybeReadLine()
        {
            if (tokens.Count > 0)
            {
                return;
            }
            string line = reader.ReadLine();
            foreach (string token in line.Split())
            {
                tokens.Enqueue(token);
            }
        }

        public int NextInt()
        {
            MaybeReadLine();
            string token = tokens.Dequeue();
            return int.Parse(token);
        }

        public long NextLong()
        {
            MaybeReadLine();
            string token = tokens.Dequeue();
            return long.Parse(token);
        }

        public double NextDouble()
        {
            MaybeReadLine();
            string token = tokens.Dequeue();
            return double.Parse(token);
        }

        public string NextString()
        {
            MaybeReadLine();
            string token = tokens.Dequeue();
            return token;
        }
    }
}

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

namespace Codeforces98
{
	class B105
	{
		static void Main(string[] args)
		{
			int ans = 0;
			int p = int.Parse(Console.ReadLine());
			int d = int.Parse(Console.ReadLine());
			int t = int.Parse(Console.ReadLine());
			int f = int.Parse(Console.ReadLine());
			int c = int.Parse(Console.ReadLine());

			if (p >= d)
			{
				Console.WriteLine(0);
				return;
			}

			double r = 0;
			double r1 = p * t; // отошла

			double t1 = (r + r1) / (d - p); // догнал через
			double t2 = 0;
			double r2 = t1 * p;	// за это время прошла
			r = r + r1 + r2; // ушла всего на

			while ( Math.Abs(c - r) > 1e-12 && c > r)
			{
				ans++;
				t2 = r / d + f; // д потратил на возврат
				r1 = p * t2;	// п за это время ушла еще на
				t1 = (r + r1) / (d - p); // догнал через
				r2 = t1 * p;	// за это время прошла
				r = r + r1 + r2;
			}
			Console.WriteLine(ans);

//			Console.ReadKey();
		}
	}
}

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

class c105_p2
{
    static void Main()
    {
        //Console.SetIn(new StreamReader(new FileStream("../../in.txt", FileMode.Open)));
        //StreamWriter out_sw = new StreamWriter(new FileStream("../../out.txt", FileMode.Create));
        //Console.SetOut(out_sw);

        int vp = int.Parse(Console.In.ReadLine());
        int vd = int.Parse(Console.In.ReadLine());
        int t = int.Parse(Console.In.ReadLine());
        int f = int.Parse(Console.In.ReadLine());
        int c = int.Parse(Console.In.ReadLine());

        if (vp > vd)
        {
            Console.Out.WriteLine(0);
            return;
        }

        if (vp == vd)
        {
            if (t == 0) Console.Out.WriteLine(1);
            else Console.Out.WriteLine(0);
            return;
        }

        double d = t*vp;
        int counter = 0;
        while (true)
        {
            double go_t = d / (vd - vp);
            d += go_t * vp;
            if (d >= c) break;
            counter ++;
            d += ((d / vd) + f) * vp;
        }

        Console.Out.WriteLine(counter);

        //out_sw.Close();
    }
}

using System; using System.Linq;

class P {
  static void Main() {
    var vp = int.Parse(Console.ReadLine());
    var vd = int.Parse(Console.ReadLine());
    var latency = double.Parse(Console.ReadLine());
    var f = int.Parse(Console.ReadLine());
    var c = int.Parse(Console.ReadLine());

    if (vp >= vd) { Console.Write(0); return; }
    var dv = 1.0*vd - vp;

    var advantage = 0.0000000001 + latency*vp;
    var drugs = 0;
    while (advantage < c) {
      var t = advantage / dv;
      if (advantage + t*vp >= c) break;

      t = 2*t + f;
      drugs++;
      advantage += t * vp;
    }
    Console.Write(drugs);
  }
}

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

namespace ConsoleApplication121
{
    class Program
    {
        static void Main(string[] args)
        {
            var vp = int.Parse(Console.ReadLine());
            var vd = int.Parse(Console.ReadLine());
            var latency = double.Parse(Console.ReadLine());
            var f = int.Parse(Console.ReadLine());
            var c = int.Parse(Console.ReadLine());

            if (vp >= vd)
            { Console.Write(0);
            Environment.Exit(0);
            }
            var dv = 1.0 * vd - vp;

            var advantage = 0.0000000001 + latency * vp;
            var drugs = 0;
            while (advantage < c)
            {
                var t = advantage / dv;
                if (advantage + t * vp >= c) break;

                t = 2 * t + f;
                drugs++;
                advantage += t * vp;
            }
            Console.Write(drugs);
        }
    }
}

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

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

        private static void Main(string[] args)
        {
            int vp = Next(), vd = Next(), t = Next(), f = Next(), c = Next();

            t *= vp*vd;
            f *= vp * vd;
            c *= vp * vd;

            int count = 0;
            int p = 0;
            int d = 0;
            int ds = 0;
            int towait = t;
            while (true)
            {
                p += vp;

                if (ds == 0)
                {
                    towait--;
                    if (towait < 0)
                    {
                        ds = 1;
                        d += vd;
                    }
                }
                else if (ds == 1)
                {
                    d += vd;
                }
                else
                {
                    d -= vd;
                }

                if (d >= p)
                {
                    if (d==p &&p==c)
                        break;
                    count++;
                    ds = 2;
                    d = p - (d - p);
                }

                if (ds == 2 && d <= 0)
                {
                    d = -d;
                    ds = 0;
                    towait = f;
                }

                if (p >= c)
                {
                    break;
                }
            }

            writer.WriteLine(count);
            writer.Flush();
        }

        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';
            }
        }
    }
}

#if DEBUG
using System.Reflection;
using System.Threading.Tasks;
#endif

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

namespace _105d2a
{
    class Program
    {
        static string _inputFilename = "input.txt";
        static string _outputFilename = "output.txt";
#if DEBUG
        static bool _useFileInput = false;
#else
        static bool _useFileInput = false;
#endif

        static void Main(string[] args)
        {
            StreamWriter file = null;
            if (_useFileInput)
            {
                Console.SetIn(File.OpenText(_inputFilename));
                file = new StreamWriter(_outputFilename);
                Console.SetOut(file);
            }

#if DEBUG
			if (!_useFileInput)
			{
				Console.SetIn(getInput());
			}
#endif

            try
            {
                solution();
            }
            finally
            {
                if (_useFileInput)
                {
                    file.Close();
                }
            }
        }

        static void solution()
        {
            #region SOLUTION
            var vp = readInt();
            var vd = readInt();
            var t = readInt();
            var f = readInt();
            var c = readInt();

            if (vp >= vd)
            {
                Console.WriteLine(0);
                return;
            }

            var l = 0;
            var r = c;
            while (true)
            {
                if (l == r)
                {
                    break;
                }

                var m = l + (r - l) / 2;
                var count = m;
                double start = vp * t;
                var can = false;
                while (true)
                {
                    if (start >= c)
                    {
                        can = true;
                        break;
                    }

                    var nmt = start / (double)(vd - vp);
                    var pos = nmt * vd;

                    if (pos >= c)
                    {
                        can = true;
                        break;
                    }

                    if (count == 0)
                    {
                        can = false;
                        break;
                    }

                    count--;
                    start = pos + f * vp + nmt * vp;
                }

                if (can)
                {
                    r = m;
                }
                else
                {
                    l = m + 1;
                }
            }

            Console.WriteLine(l);
            //var n = readInt();
            //var m = readInt();

            //var a = readIntArray();
            //var b = readIntArray();
            #endregion
        }

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

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

        static int[] readIntArray()
        {
            return Console.ReadLine().Split(' ').Where(i => !string.IsNullOrEmpty(i)).Select(i => int.Parse(i)).ToArray();
        }

        static long[] readLongArray()
        {
            return Console.ReadLine().Split(' ').Where(i => !string.IsNullOrEmpty(i)).Select(i => long.Parse(i)).ToArray();
        }

#if DEBUG
		static StreamReader getInput()
		{
			var resName = Assembly.GetCallingAssembly().GetManifestResourceNames()[0];
			var resource = Assembly.GetCallingAssembly().GetManifestResourceStream(resName);

			return new StreamReader(resource);
		}
#endif
    }
}

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

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

            int coins = 0;
            int vp = int.Parse(Console.ReadLine());
            int vd = int.Parse(Console.ReadLine());
            double t = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());

            while (true)
            {
                double m = t * vp;
                double n = m / (vd - vp);
                double di = n * vd;
                if(di<d&&vp<vd)
                {
                    double i = di / vp;
                    double ii = di / vd;
                    t = (i + f + ii);
                    coins++;
                }
               else
                {
                    break;
                }
            }

            Console.WriteLine(coins);
        }
    }
}

using System;

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

            string vp = Console.ReadLine();
            string vd = Console.ReadLine();
            string t = Console.ReadLine();
            string f = Console.ReadLine();
            string c = Console.ReadLine();

            Console.WriteLine(Money(vp, vd, t, f, c));
        }

        static public int Money(string vp1, string vd1, string t1, string f1, string c1)
        {
            int vp = Int32.Parse(vp1);
            int vd = Int32.Parse(vd1);
            double t = Int32.Parse(t1);
            int c = Int32.Parse(c1);
            if (vp > vd) return 0;
            int number = 0;
            double s = 0;
            while (s < c)
            {
                s += vd * t / (vd - vp)* vp;
                t = s/ vd * 2 + Double.Parse(f1);
                if (s < c)
                    number++;
            }
            return number;
        }

    }
}

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

namespace _105b
{
    class Program
    {
        class Scanner
        {
            string[] s;
            int i;

            char[] cs = new char[] { ' ' };

            public Scanner()
            {
                s = new string[0];
                i = 0;
            }

            public string next()
            {
                if (i < s.Length) return s[i++];
                s = Console.ReadLine().Split(cs, StringSplitOptions.RemoveEmptyEntries);
                i = 0;
                return s[i++];
            }

            public int nextInt()
            {
                return int.Parse(next());
            }

            public double nextDouble()
            {
                return (double)nextInt();
            }

            public long nextLong()
            {
                return long.Parse(next());
            }

        }
        static void Main(string[] args)
        {
            Scanner sc = new Scanner();
            double vp = 1;// sc.nextDouble();
            double vd = 2;// sc.nextDouble();
            double t = 1;// sc.nextDouble();
            double f = 1;// sc.nextDouble();
            double c = 10;// sc.nextDouble();
            if (vp >= vd)
            {
                Console.WriteLine(0);
                return;
            }
            int count = 0;
            double H;
            double t0;
            H = vp * t;
            while (true)
            {
                t0 = H / (vd - vp);

                H += vp * t0;

                if (H >= (double)c)
                {
                    Console.WriteLine(count);
                    return;
                }
                else
                {
                    count++;
                    t0 = (H / vd) + f;
                    H += vp * t0;
                }
            }

        }
    }
}

using System;

class Program
{
    static void Main(string[] args)
    {
        double vp = Convert.ToDouble(Console.ReadLine());
        double vd = Convert.ToDouble(Console.ReadLine());
        double t = Convert.ToDouble(Console.ReadLine());
        double f = Convert.ToDouble(Console.ReadLine());
        double c = Convert.ToDouble(Console.ReadLine());
        double put = t * vp;
        if(vp==vd)
        {
            Console.WriteLine(0);
            return;
        }
        double otr = put;
        double prom;
        int dr = 0;
        //int dput = 0;
        while (put < c)
        {
            prom = vd - vp;
            prom = put / prom;
            prom = prom * vp;
            put += prom;
            if (put >= c)
            {
                Console.WriteLine(dr);
                //Console.ReadKey();
                return;
            }
            else
            {
                dr++;
                prom = put / vd;
                prom = vp * prom;
                put += prom;
                prom = vp * f;
                put += prom;
                otr = put;
            }
        }
    Console.WriteLine(dr);
    //Console.ReadKey();
    return;

    }
}

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

    class Program
    {
        static void Main(string[] args)
        {
            string g = f();
            Console.WriteLine(g);
            Console.ReadLine();

        }

        public static string f()
        {
            int vp = int.Parse(Console.ReadLine());
            int vd = int.Parse(Console.ReadLine());
            int t = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int t1 = t;
            int t2 = 0;
            int tp = 0;
            for (int i = 1; i < 1000; i++)
            {
                t2 = Math.Abs((vp*t1 - vd*t1) / (vd - vp));
                if ((vp * t2+vp*t1) >= c)
                {
                    return tp.ToString();
                }
                tp++;
                t1 = t1 + t2 + f + (t1 + t2) / vd;
            }
            return "";
        }
    }

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

    class Program
    {
        static void Main(string[] args)
        {
            string g = f();
            Console.WriteLine(g);
            Console.ReadLine();

        }

        public static string f()
        {
            int vp = int.Parse(Console.ReadLine());
            int vd = int.Parse(Console.ReadLine());
            int t = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            float t1 = t;
            float t2 = 0;
            int tp = 0;
            for (int i = 1; i < 1000; i++)
            {
                t2 = Math.Abs((vp*t1) / (vd - vp));
                if ((vp * t2+vp*t1) >= c)
                {
                    return tp.ToString();
                }
                tp=tp+1;
                t1 = t1 + t2 + f + t2;
            }
            return "";
        }
    }

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

   class Program
    {
        static void Main(string[] args)
        {
            string g = f();
            Console.WriteLine(g);
            Console.ReadLine();

        }

        public static string f()
        {
            int vp = int.Parse(Console.ReadLine());
            int vd = int.Parse(Console.ReadLine());
            int t = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int t1 = t;
            int t2 = 0;
            int tp = 0;
            for (int i = 1; i < 1000; i++)
            {
                t2 = Math.Abs((vp*t1 - vd*t1) / (vd - vp));
                if ((vp * t2+vp*t1) >= c)
                {
                    return tp.ToString();
                }
                tp++;
                t1 = t1 + t2 + i + (t1 + t2) / vd;
            }
            return "";
        }
    }

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

namespace J
{
    class Program
    {
        static void Main(string[] args)
        {
            int vp = Convert.ToInt32(Console.ReadLine());
            int vd = Convert.ToInt32(Console.ReadLine());
            int t = Convert.ToInt32(Console.ReadLine());
            int f = Convert.ToInt32(Console.ReadLine());
            int c = Convert.ToInt32(Console.ReadLine());
            double l = c - t * vp;
            double ft = ((double)c / vp) - t;
            int s = 0;
            double tempt;
            while (true)
            {
                tempt = (double)(c - l) / (vd - vp);
                ft -= tempt;
                if (ft > 0)
                {
                    s++;
                }
                l = l - (2*tempt+f) * vp;
                ft -= tempt;
                ft -= f;
                if (ft <= 0)
                {
                    break;
                }

            }
            Console.WriteLine(s);

        }
    }
}

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

namespace B
{
    class Program
    {
        static void Main(string[] args)
        {
            int vp = int.Parse(Console.ReadLine().Trim());
            int vd = int.Parse(Console.ReadLine().Trim());
            int late = int.Parse(Console.ReadLine().Trim());
            int wait = int.Parse(Console.ReadLine().Trim());
            int distance = int.Parse(Console.ReadLine().Trim());

            double p = vp * late;
            int drag = 0;

            while (p < distance)
            {
                double time1 = p;
                time1 /= (vd - vp);

                double delta = time1 * vp;

                p += delta;

                if (p >= distance)
                {
                    break;
                }

                ++drag;

                double time2 = p;
                time2 /= vd;

                time2 += wait;

                double delta2 = time2 * vp;
                p += delta2;
            }

            Console.WriteLine(drag);
        }
    }
}

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

namespace Task
{
    #region MyIo

    class MyIo : IDisposable
    {
        private readonly TextReader inputStream;
        private readonly TextWriter outputStream = Console.Out;

        string[] tokens;
        int pointer;

        public MyIo()
#if  LOCAL_TEST
            : this(new StreamReader("input.txt"))
#else
            : this(System.Console.In)
#endif
        {

        }

        public MyIo(TextReader inputStream)
        {
            this.inputStream = inputStream;
        }

        public string NextLine()
        {
            try
            {
                return inputStream.ReadLine();
            }
            catch (IOException)
            {
                return null;
            }
        }

        public string NextString()
        {
            try
            {
                while (tokens == null || pointer >= tokens.Length)
                {
                    tokens = NextLine().Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
                    pointer = 0;
                }
                return tokens[pointer++];
            }
            catch (IOException)
            {
                return null;
            }
        }

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

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

        public void Print(string format, params object[] args)
        {
            outputStream.Write(string.Format(CultureInfo.InvariantCulture, format, args));
        }

        public void PrintLine(string format, params object[] args)
        {
            Print(format, args);

            outputStream.WriteLine();
        }

        public void Print<T>(T o)
        {
            outputStream.Write(o);
        }

        public void PrintLine<T>(T o)
        {
            outputStream.WriteLine(o);
        }

        public void Close()
        {
            inputStream.Close();
            outputStream.Close();
        }

        void IDisposable.Dispose()
        {
            Close();

#if  LOCAL_TEST
            Console.ReadLine();
#endif
        }
    }
    #endregion

    class Program
    {
        #region Program

        readonly MyIo io;

        public Program(MyIo io)
        {
            this.io = io;
        }

        static void Main(string[] args)
        {
            using (MyIo io = new MyIo())
            {
                new Program(io)
                    .Solve();
            }
        }

        #endregion

        void Solve()
        {
            var vp = (double)io.NextInt();
            var vd = (double)io.NextInt();
            var t = (double)io.NextInt();
            var f = (double)io.NextInt();
            var c = (double)io.NextInt();

            int res = 0;

            if (vp < vd)
            {
                var fm = (vp * vp/ (vd - vp) + vp) * t;

                var coef = vd * vd / (vp * vp) - vd / vp;

                var coef1 = f * vd / coef;

                while (fm < c)
                {
                    res++;

                    fm = CalcNext(fm, coef, coef1);
                }
            }

            io.Print(res);
        }

        public double CalcNext(double prev, double coef, double coef1)
        {
            return (2*prev / coef + coef1) * 2.0 + prev;
        }
    }
}

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

namespace Task
{
    #region MyIo

    class MyIo : IDisposable
    {
        private readonly TextReader inputStream;
        private readonly TextWriter outputStream = Console.Out;

        string[] tokens;
        int pointer;

        public MyIo()
#if  LOCAL_TEST
            : this(new StreamReader("input.txt"))
#else
            : this(System.Console.In)
#endif
        {

        }

        public MyIo(TextReader inputStream)
        {
            this.inputStream = inputStream;
        }

        public string NextLine()
        {
            try
            {
                return inputStream.ReadLine();
            }
            catch (IOException)
            {
                return null;
            }
        }

        public string NextString()
        {
            try
            {
                while (tokens == null || pointer >= tokens.Length)
                {
                    tokens = NextLine().Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
                    pointer = 0;
                }
                return tokens[pointer++];
            }
            catch (IOException)
            {
                return null;
            }
        }

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

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

        public void Print(string format, params object[] args)
        {
            outputStream.Write(string.Format(CultureInfo.InvariantCulture, format, args));
        }

        public void PrintLine(string format, params object[] args)
        {
            Print(format, args);

            outputStream.WriteLine();
        }

        public void Print<T>(T o)
        {
            outputStream.Write(o);
        }

        public void PrintLine<T>(T o)
        {
            outputStream.WriteLine(o);
        }

        public void Close()
        {
            inputStream.Close();
            outputStream.Close();
        }

        void IDisposable.Dispose()
        {
            Close();

#if  LOCAL_TEST
            Console.ReadLine();
#endif
        }
    }
    #endregion

    class Program
    {
        #region Program

        readonly MyIo io;

        public Program(MyIo io)
        {
            this.io = io;
        }

        static void Main(string[] args)
        {
            using (MyIo io = new MyIo())
            {
                new Program(io)
                    .Solve();
            }
        }

        #endregion

        void Solve()
        {
            var vp = (double)io.NextInt();
            var vd = (double)io.NextInt();
            var t = (double)io.NextInt();
            var f = (double)io.NextInt();
            var c = (double)io.NextInt();

            int res = 0;

            if (vp < vd)
            {

                while (c > 0)
                {
                    var x = (vp / (vd - vp) + 1) * t * vp;
                    t = 2 * x / vd + f;

                    c -= x;

                    if (c > 0)
                        res++;
                }
            }

            io.Print(res);
        }

    }
}

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

namespace CF105
{
    // B
    class Escape
    {
        static void Main(string[] args)
        {
            int vp = int.Parse(Console.ReadLine());
            int vd = int.Parse(Console.ReadLine());
            int t = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());

            if (vp >= vd)
            {
                Console.WriteLine(0);
                return;
            }

            int bijous = 0;
            float xp = t * vp;
            float xd = 0;
            bool chasing = true;
            while (xp < c + 1E-6)
            {
                Console.WriteLine(String.Format("xp={0}, xd={1}", xp, xd));
                // If they meet this step
                if (chasing && xp - xd < vd - vp + 1E-6)
                {
                    float timeToMeet = (xd - xp) / (vp - vd);
                    xd += timeToMeet * vd;
                    xp += timeToMeet * vp;
                    bijous++;
                    chasing = false;
                }
                // If dragon gets back this step
                else if (!chasing && xd <= vd + 1E-6)
                {
                    float timeToGetBack = xd / vd;
                    xd = 0;
                    xp += (timeToGetBack + f) * vp;
                    chasing = true;
                }
                // Normal move turn
                else
                {
                    xp += vp;

                    if (chasing)
                        xd += vd;
                    else
                        xd -= vd;
                }
            }

            Console.WriteLine(bijous);
            //Console.Read();
        }
    }
}

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

namespace CF105
{
    // B
    class Escape
    {
        static void Main(string[] args)
        {
            int vp = int.Parse(Console.ReadLine());
            int vd = int.Parse(Console.ReadLine());
            int t = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());

            if (vp >= vd)
            {
                Console.WriteLine(0);
                return;
            }

            int bijous = 0;
            float xp = t * vp;
            float xd = 0;
            bool chasing = true;
            while (xp < c)
            {
                Console.WriteLine(String.Format("xp={0}, xd={1}", xp, xd));
                // If they meet this step
                if (chasing && xp - xd < vd - vp)
                {
                    float timeToMeet = (xd - xp) / (vp - vd);
                    xd += timeToMeet * vd;
                    xp += timeToMeet * vp;
                    bijous++;
                    chasing = false;
                }
                // If dragon gets back this step
                else if (!chasing && xd <= vd)
                {
                    float timeToGetBack = xd / vd;
                    xd = 0;
                    xp += (timeToGetBack + f) * vp;
                    chasing = true;
                }
                // Normal move turn
                else
                {
                    xp += vp;

                    if (chasing)
                        xd += vd;
                    else
                        xd -= vd;
                }
            }

            Console.WriteLine(bijous);
            //Console.Read();
        }
    }
}

using System;
using System.Linq;

namespace olimpP
{
	class MainClass
	{
		public static void Main (string[] args)
		{

			int a = Convert.ToInt32 (Console.ReadLine());
			int b = Convert.ToInt32 (Console.ReadLine());
			int c = Convert.ToInt32 (Console.ReadLine());
			int d = Convert.ToInt32 (Console.ReadLine());
			int e = Convert.ToInt32 (Console.ReadLine());

			Console.WriteLine(Func4 (a,b,c,d,e));

		}

		public static int Func4(int vs, int vp, int tf, int td, int c)
		{
			int count = 0;
			int sum = vs * tf;
			int sum2 = 0;
			string align = "race";
			int time = (c - sum) / vs;
			int time1 = tf;
			int temp = 0;
			while (time1 < time) {
				if (sum2 <= 0 && temp>0) {
					sum += vs;
					align = "race";
					temp--;
				}
				else {
					if (align == "race") {
						sum += vs;
						sum2 += vp;
					}
					if (align == "home") {
						sum += vs;
						sum2 -= vp;
					}
					if (sum <= sum2) {
						count++;
						align = "home";
						temp = td;
					}
				}
				time1++;
			}
			return count;
		}
	}
}

using System;
using System.Linq;

namespace olimpP
{
	class MainClass
	{
		public static void Main (string[] args)
		{
			int a = Convert.ToInt32 (Console.ReadLine());
			int b = Convert.ToInt32 (Console.ReadLine());
			int c = Convert.ToInt32 (Console.ReadLine());
			int d = Convert.ToInt32 (Console.ReadLine());
			int e = Convert.ToInt32 (Console.ReadLine());

			Console.WriteLine(Func4 (a,b,c,d,e));

		}

		public static int Func4(int vs, int vp, int tf, int td, int c)
		{
			int count = 0;
			int S = 0;
			while (S < c)
			{
				S += (-vs) * vp * tf / (vp - vs); // ГАИ догонят Васю на расстоянии S
				if (S < c)
					count++;
				// S/vd + f потратят на возврат и разделение
				tf = S / vs * 2 + td;
			}
			return count-1;
		}
	}
}

using System;
using System.Linq;

namespace olimpP
{
	class MainClass
	{
		public static void Main (string[] args)
		{
			int a = Convert.ToInt32 (Console.ReadLine());
			int b = Convert.ToInt32 (Console.ReadLine());
			int c = Convert.ToInt32 (Console.ReadLine());
			int d = Convert.ToInt32 (Console.ReadLine());
			int e = Convert.ToInt32 (Console.ReadLine());

			Console.WriteLine(Func4 (a,b,c,d,e));

		}

		public static int Func4(int vs, int vp, int tf, int td, int c)
		{
			int count = 0;
			int S = 0;
			while (S < c)
			{
				S += (-vp) * vs * tf / (vs - vp); // ГАИ догонят Васю на расстоянии S
				if (S < c)
					count++;
				// S/vd + f потратят на возврат и разделение
				tf = S / vp * 2 + td;
			}
			return count;
		}
	}
}

using System;
using System.Linq;

namespace olimpP
{
	class MainClass
	{
		public static void Main (string[] args)
		{

			int a = Convert.ToInt32 (Console.ReadLine());
			int b = Convert.ToInt32 (Console.ReadLine());
			int c = Convert.ToInt32 (Console.ReadLine());
			int d = Convert.ToInt32 (Console.ReadLine());
			int e = Convert.ToInt32 (Console.ReadLine());

			Console.WriteLine(Func4 (a,b,c,d,e));

		}

		public static int Func4(int vs, int vp, int tf, int td, int c)
		{
			int count = 0;
			int time = c/vs;
			int time1 = 0;
			int temp = tf;
			while (time1< time){
				time1 = (vp*temp) / ((vp - vs));
				temp = 2*time1 - temp + tf;
				if (time1 < time)
				count++;
			}
			return count;
		}
	}
}

using System;
using System.Linq;

namespace olimpP
{
	class MainClass
	{
		public static void Main (string[] args)
		{
			int a = Convert.ToInt32 (Console.ReadLine());
			int b = Convert.ToInt32 (Console.ReadLine());
			int c = Convert.ToInt32 (Console.ReadLine());
			int d = Convert.ToInt32 (Console.ReadLine());
			int e = Convert.ToInt32 (Console.ReadLine());

			Console.WriteLine(Func4 (a,b,c,d,e));

		}

		public static int Func4(int vs, int vp, int tf, int td, int c)
		{
			int count = 0;
			int S = 0;
			while (S < c)
			{
				S += (-vp) * vs * tf / (vs - vp); // ГАИ догонят Васю на расстоянии S
				if (S < c)
					count++;
				// S/vd + f потратят на возврат и разделение
				tf = S / vp * 2 + td;
			}
			return count-1;
		}
	}
}

using System;
using System.Linq;

namespace olimpP
{
	class MainClass
	{
		public static void Main (string[] args)
		{

			int a = Convert.ToInt32 (Console.ReadLine());
			int b = Convert.ToInt32 (Console.ReadLine());
			int c = Convert.ToInt32 (Console.ReadLine());
			int d = Convert.ToInt32 (Console.ReadLine());
			int e = Convert.ToInt32 (Console.ReadLine());

			Console.WriteLine(Func4 (a,b,c,d,e));

		}

		public static int Func4(int vs, int vp, int tf, int td, int c)
		{
			int count = 0;
			int sum = vs * tf;
			int sum2 = 0;
			string align = "race";
			int time = (c - sum) / vs;
			int time1 = tf;
			int temp = 0;
			while (time1 < time) {
				if (sum2 <= 0 && temp>0) {
					sum += vs;
					align = "race";
					temp--;
				}
				else {
					if (align == "race") {
						sum += vs;
						sum2 += vp;
					}
					if (align == "home") {
						sum += vs;
						sum2 -= vp;
					}
					if (sum == sum2) {
						count++;
						align = "home";
						temp = td;
					}
				}
				time1++;
			}
			return count;
		}
	}
}

using System;
using System.Linq;

namespace olimpP
{
	class MainClass
	{
		public static void Main (string[] args)
		{

			int a = Convert.ToInt32 (Console.ReadLine());
			int b = Convert.ToInt32 (Console.ReadLine());
			int c = Convert.ToInt32 (Console.ReadLine());
			int d = Convert.ToInt32 (Console.ReadLine());
			int e = Convert.ToInt32 (Console.ReadLine());

			Console.WriteLine(Func4 (a,b,c,d,e));

		}

		public static int Func4(int vs, int vp, int tf, int td, int c)
		{
			int count = 0;
			int sum = vs * tf;
			int sum2 = 0;
			string align = "race";
			int time = (c) / vs;
			int time1 = tf;
			int temp = 0;
			while (time1 < time) {
				if (sum2 <= 0 && temp>0) {
					sum += vs;
					align = "race";
					temp--;
				}
				else {
					if (align == "race") {
						sum += vs;
						sum2 += vp;
					}
					if (align == "home") {
						sum += vs;
						sum2 -= vp;
					}
					if (sum <= sum2) {
						count++;
						align = "home";
						temp = td;
					}
				}
				time1++;
			}
			return count;
		}
	}
}

using System;
using System.Linq;

namespace olimpP
{
	class MainClass
	{
		public static void Main (string[] args)
		{

			int a = Convert.ToInt32 (Console.ReadLine());
			int b = Convert.ToInt32 (Console.ReadLine());
			int c = Convert.ToInt32 (Console.ReadLine());
			int d = Convert.ToInt32 (Console.ReadLine());
			int e = Convert.ToInt32 (Console.ReadLine());

			Console.WriteLine(Func4 (a,b,c,d,e));

		}

		public static int Func4(int vs, int vp, double tf, int td, int c)
		{
			int count = 0;
			int time = c/vs;
			double time1 = 0;
			while (time1 < time){
				time1 = (vp*tf) / ((vp - vs));
				tf = time1 - tf + td+ time1;
				if (time1 < time)
					count++;
			}
			return count;
		}
	}
}

using System;
using System.Linq;

namespace olimpP
{
	class MainClass
	{
		public static void Main (string[] args)
		{
			int a = Convert.ToInt32 (Console.ReadLine());
			int b = Convert.ToInt32 (Console.ReadLine());
			int c = Convert.ToInt32 (Console.ReadLine());
			int d = Convert.ToInt32 (Console.ReadLine());
			int e = Convert.ToInt32 (Console.ReadLine());

			Console.WriteLine(Func4 (a,b,c,d,e));

		}

		public static int Func4(int vs, int vp, int tf, int td, int c)
		{
			int count = 0;
			int sum = vs * tf;
			int sum2 = 0;
			string align = "race";
			int time = c / vs;
			int time1 = tf;
			int temp = 0;
			while (time1 < time) {
				sum += vs;
				if (align == "race")
					sum2 += vp;
				if (sum == sum2) {
					align = "house";
					count++;
				}
				if (align == "house")
					sum2 -= vp;
				if (sum <= 0) temp = time1 + td;
				if (temp==time1) align = "race";
				time1++;

			}

			return count;
		}
	}
}

using System;
using System.Linq;

namespace olimpP
{
	class MainClass
	{
		public static void Main (string[] args)
		{
			int a = Convert.ToInt32 (Console.ReadLine());
			int b = Convert.ToInt32 (Console.ReadLine());
			int c = Convert.ToInt32 (Console.ReadLine());
			int d = Convert.ToInt32 (Console.ReadLine());
			int e = Convert.ToInt32 (Console.ReadLine());

			Console.WriteLine(Func4 (a,b,c,d,e));

		}

		public static int Func4(int vs, int vp, int tf, int td, int c)
		{
			int count = 0;
			int sum = vs * tf;
			int sum2 = 0;
			string align = "race";
			int time = c / vs;
			int time1 = tf;
			int temp = 0;
			while (time1 <= time) {
				sum += vs;
				if (temp==time1) align = "race";

				if (align == "race")
					sum2 += vp;
				if (sum <= sum2) {
					align = "house";
					count++;
				}
				if (align == "house")
					sum2 -= vp;
				if (sum2<= 0) temp = time1 + td;
				if (temp==time1) align = "race";
				time1++;

			}

			return count-1;
		}
	}
}

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

namespace Codeforces98
{
	class B105
	{
		static void Main(string[] args)
		{
			int ans = 0;
			int p = int.Parse(Console.ReadLine());
			int d = int.Parse(Console.ReadLine());
			int t = int.Parse(Console.ReadLine());
			int f = int.Parse(Console.ReadLine());
			int c = int.Parse(Console.ReadLine());

			double r = 0;
			double r1 = p * t; // отошла

			double t1 = (r + r1) / (d - p); // догнал через
			double t2 = 0;
			double r2 = t1 * p;	// за это время прошла
			r = r + r1 + r2; // ушла всего на

			while ( Math.Abs(c - r) > 1e-12 && c > r)
			{
				ans++;
				t2 = r / d + f; // д потратил на возврат
				r1 = p * t2;	// п за это время ушла еще на
				t1 = (r + r1) / (d - p); // догнал через
				r2 = t1 * p;	// за это время прошла
				r = r + r1 + r2;
			}
			Console.WriteLine(ans);

//			Console.ReadKey();
		}
	}
}

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

class c105_p2
{
    static void Main()
    {
        //Console.SetIn(new StreamReader(new FileStream("../../in.txt", FileMode.Open)));
        //StreamWriter out_sw = new StreamWriter(new FileStream("../../out.txt", FileMode.Create));
        //Console.SetOut(out_sw);

        int vp = int.Parse(Console.In.ReadLine());
        int vd = int.Parse(Console.In.ReadLine());
        int t = int.Parse(Console.In.ReadLine());
        int f = int.Parse(Console.In.ReadLine());
        int c = int.Parse(Console.In.ReadLine());

        double d = t*vp;
        int counter = 0;
        while (true)
        {
            double go_t = d / (vd - vp);
            d += go_t * vp;
            if (d >= c) break;
            counter ++;
            d += ((d / vd) + f) * vp;
        }

        Console.Out.WriteLine(counter);

        //out_sw.Close();
    }
}

using System; using System.Linq;

class P {
  static void Main() {
    var vp = int.Parse(Console.ReadLine());
    var vd = int.Parse(Console.ReadLine());
    var latency = double.Parse(Console.ReadLine());
    var f = int.Parse(Console.ReadLine());
    var c = int.Parse(Console.ReadLine());

    if (vp >= vd) { Console.Write(0); return; }
    var dv = 1.0*vd - vp;

    var advantage = 0.0000000001;
    var drugs = 0;
    while (advantage < c) {
      var t = advantage / dv;
      if (advantage + t*vp >= c) break;

      t = 2*t + f;
      drugs++;
      advantage += t * vp;
    }
    Console.Write(drugs);
  }
}

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

namespace ConsoleApplication121
{
    class Program
    {
        static void Main(string[] args)
        {
            int vp = int.Parse(Console.ReadLine());
            int vd = int.Parse(Console.ReadLine());
            int t = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int vd1=vd;
            int vp1=vp;
            int n = vp * t;
            n = n + vp;
            int p;
            int k = 0;
            for (int i = 2; i <=c/vp;)
            {
                if (n <= vd1)
                {
                    k++;
                    p = vd1 / vd;
                    n = n +(p* vp)+(f*vp);
                    i =i+p+f+1;
                    vd1 = 0;
                }
                else
                {
                    n = n + vp;
                    vd1 = vd1 + vd;
                    i++;
                }
            }
            Console.WriteLine(k);
        }
    }
}

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

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

        private static void Main(string[] args)
        {
            int vp = Next(), vd = Next(), t = Next(), f = Next(), c = Next();

            int count = 0;
            int p = 0;
            int d = 0;
            int ds = 0;
            int towait = t;
            while (true)
            {
                p += vp;
                if (p >= c)
                    break;

                if (ds == 0)
                {
                    towait--;
                    if (towait < 0)
                    {
                        ds = 1;
                        d = vd;
                    }
                }
                else if (ds == 1)
                {
                    d += vd;
                }
                else
                {
                    d -= vd;
                }

                if (d >= p)
                {
                    count++;
                    ds = 2;
                    d = p - (d - p);
                }

                if (ds == 2 && d <= 0)
                {
                    d = 0;
                    ds = 0;
                    towait = f;
                }
            }

            writer.WriteLine(count);
            writer.Flush();
        }

        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';
            }
        }
    }
}

#if DEBUG
using System.Reflection;
using System.Threading.Tasks;
#endif

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

namespace _105d2a
{
    class Program
    {
        static string _inputFilename = "input.txt";
        static string _outputFilename = "output.txt";
#if DEBUG
        static bool _useFileInput = false;
#else
        static bool _useFileInput = false;
#endif

        static void Main(string[] args)
        {
            StreamWriter file = null;
            if (_useFileInput)
            {
                Console.SetIn(File.OpenText(_inputFilename));
                file = new StreamWriter(_outputFilename);
                Console.SetOut(file);
            }

#if DEBUG
			if (!_useFileInput)
			{
				Console.SetIn(getInput());
			}
#endif

            try
            {
                solution();
            }
            finally
            {
                if (_useFileInput)
                {
                    file.Close();
                }
            }
        }

        static void solution()
        {
            #region SOLUTION
            var vp = readInt();
            var vd = readInt();
            var t = readInt();
            var f = readInt();
            var c = readInt();

            if (vp >= vd )
            {
                Console.WriteLine(0);
                return;
            }

            var l = 0;
            var r = c;
            while (true)
            {
                if (l == r)
                {
                    break;
                }

                var m = l + (r - l) / 2;
                var count = m;
                var start = vp * t;
                var can = false;
                while (true)
                {
                    if (start >= c)
                    {
                        can = true;
                        break;
                    }

                    var nmt = start / (vd - vp);
                    var pos = nmt * vd;

                    if (pos >= c)
                    {
                        can = true;
                        break;
                    }

                    if (count == 0)
                    {
                        can = false;
                        break;
                    }

                    count--;
                    start = pos + f * vp + nmt * vp;
                }

                if (can)
                {
                    r = m;
                }
                else
                {
                    l = m + 1;
                }
            }

            Console.WriteLine(l);
            //var n = readInt();
            //var m = readInt();

            //var a = readIntArray();
            //var b = readIntArray();
            #endregion
        }

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

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

        static int[] readIntArray()
        {
            return Console.ReadLine().Split(' ').Where(i => !string.IsNullOrEmpty(i)).Select(i => int.Parse(i)).ToArray();
        }

        static long[] readLongArray()
        {
            return Console.ReadLine().Split(' ').Where(i => !string.IsNullOrEmpty(i)).Select(i => long.Parse(i)).ToArray();
        }

#if DEBUG
		static StreamReader getInput()
		{
			var resName = Assembly.GetCallingAssembly().GetManifestResourceNames()[0];
			var resource = Assembly.GetCallingAssembly().GetManifestResourceStream(resName);

			return new StreamReader(resource);
		}
#endif
    }
}

#if DEBUG
using System.Reflection;
using System.Threading.Tasks;
#endif

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

namespace _105d2a
{
    class Program
    {
        static string _inputFilename = "input.txt";
        static string _outputFilename = "output.txt";
#if DEBUG
        static bool _useFileInput = false;
#else
        static bool _useFileInput = false;
#endif

        static void Main(string[] args)
        {
            StreamWriter file = null;
            if (_useFileInput)
            {
                Console.SetIn(File.OpenText(_inputFilename));
                file = new StreamWriter(_outputFilename);
                Console.SetOut(file);
            }

#if DEBUG
			if (!_useFileInput)
			{
				Console.SetIn(getInput());
			}
#endif

            try
            {
                solution();
            }
            finally
            {
                if (_useFileInput)
                {
                    file.Close();
                }
            }
        }

        static void solution()
        {
            #region SOLUTION
            var vp = readInt();
            var vd = readInt();
            var t = readInt();
            var f = readInt();
            var c = readInt();

            var l = 0;
            var r = c;
            while (true)
            {
                if (l == r)
                {
                    break;
                }

                var m = l + (r - l) / 2;
                var count = m;
                var start = vp * t;
                var can = false;
                while (true)
                {
                    if (start >= c)
                    {
                        can = true;
                        break;
                    }

                    var nmt = start / (vd - vp);
                    var pos = nmt * vd;

                    if (pos >= c)
                    {
                        can = true;
                        break;
                    }

                    if (count == 0)
                    {
                        can = false;
                        break;
                    }

                    count--;
                    start = pos + f * vp + nmt * vp;
                }

                if (can)
                {
                    r = m;
                }
                else
                {
                    l = m + 1;
                }
            }

            Console.WriteLine(l);
            //var n = readInt();
            //var m = readInt();

            //var a = readIntArray();
            //var b = readIntArray();
            #endregion
        }

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

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

        static int[] readIntArray()
        {
            return Console.ReadLine().Split(' ').Where(i => !string.IsNullOrEmpty(i)).Select(i => int.Parse(i)).ToArray();
        }

        static long[] readLongArray()
        {
            return Console.ReadLine().Split(' ').Where(i => !string.IsNullOrEmpty(i)).Select(i => long.Parse(i)).ToArray();
        }

#if DEBUG
		static StreamReader getInput()
		{
			var resName = Assembly.GetCallingAssembly().GetManifestResourceNames()[0];
			var resource = Assembly.GetCallingAssembly().GetManifestResourceStream(resName);

			return new StreamReader(resource);
		}
#endif
    }
}

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

namespace Dragon
{
    class Program
    {
        static void Main(string[] args)
        {
            int op = 0;
            double p = double.Parse(Console.ReadLine());
            double d = double.Parse(Console.ReadLine());
            double c = double.Parse(Console.ReadLine());
            double f = double.Parse(Console.ReadLine());
            double dic = double.Parse(Console.ReadLine());

            for (int i = 1; i*p < dic; i++)
            {
                if(((i-c)*d)<(i*p))
                {
                }
                else
                {
                        op++;
                    double iop = i * p;
                    double iopd = iop / d;

                    c = i + iopd+f;

                }
            }
            Console.WriteLine(op);
        }
    }
}

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

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

            int coins = 0;
            int vp = int.Parse(Console.ReadLine());
            int vd = int.Parse(Console.ReadLine());
            int t = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());

            while (true)
            {
                double m = t * vp;
                double n = m / (vd - vp);
                double di = n * vd;
                if(di<d)
                {
                    int i = (int)di / vp;
                    t = i + f + ((int)di / vd);
                    coins++;
                }
               else
                {
                    break;
                }
            }

            Console.WriteLine(coins);
        }
    }
}

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

namespace Dragon
{
    class Program
    {
        static void Main(string[] args)
        {
            int op = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());

            for (int i = 1; i*p < dic; i++)
            {
                if(((i-c)*d)<(i*p))
                {
                }
                else
                {
                        op++;

                    int yy = ((i * p) / d) + f;
                    c = i + yy;

                }
            }
            Console.WriteLine(op);
        }
    }
}

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

namespace Dragon
{
    class Program
    {
        static void Main(string[] args)
        {
            int op = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());
            double n = d / p;
            for (int i = 1; i < 1000; i++)
            {
                if((c+i)/(n*i)>=1)
                {
                    if(i+c>=dic)
                    {
                        break;
                    }
                }
                else
                {
                    op++;
                    c = (((i/ d) + f) + (i));
                }
            }
            Console.WriteLine(op);
        }
    }
}

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

namespace Dragon
{
    class Program
    {
        static void Main(string[] args)
        {
            int opp = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());

            for (int i = 1; i * p < dic; i++)
            {
                if (((i - c) * d) >= (i * p) || (d - f) > p)
                {
                    opp++;
                    int iop = i * p;
                    int iopd = iop / d;
                    if (iopd == 0)
                    { iopd = 1; }
                    c = i + iopd + f;
                    i = c;

                }
                else
                {

                }
            }
            Console.WriteLine(opp);
        }
    }
}

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

namespace Dragon
{
    class Program
    {
        static void Main(string[] args)
        {
            int op = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            double c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());

            for (int i = 1; i*p < dic; i++)
            {
                if(((i-c)*d)<(i*p))
                {
                }
                else
                {
                        op++;

                    double yy = (i * p) / (double)d;
                    c = i + yy+f;
                }
            }
            Console.WriteLine(op);
        }
    }
}

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

namespace Dragon
{
    class Program
    {
        static void Main(string[] args)
        {
            int op = 0;
            double p = double.Parse(Console.ReadLine());
            double d = double.Parse(Console.ReadLine());
            double c = double.Parse(Console.ReadLine());
            double f = double.Parse(Console.ReadLine());
            double dic = double.Parse(Console.ReadLine());

            for (int i = 1; i*p < dic; i++)
            {
                if(((i-c)*d)<(i*p))
                {
                }
                else
                {
                        op++;

                    double yy = ((i * p) / d) + f;
                    c = i + yy;

                }
            }
            Console.WriteLine(op);
        }
    }
}

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

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

            int opp = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());
            //int p = 2;
            //int d = 7;
            //int c = 1;
            //int f = 1;
            //int dic = 26;

            for (int i = 1; i * p < dic; i++)
            {
                if (((i - c) * d) >= (i * p))
                {
                    opp++;
                    int iop = i * p;
                    int iopd = iop / d;
                    c = i + iopd + f;
                }
                else
                {
                    if ((p * (c + 1)) < (d))
                    {
                        opp++;
                        c++;
                    }
                }
            }
            Console.WriteLine(opp);
        }
    }
}

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

namespace Dragon
{
    class Program
    {
        static void Main(string[] args)
        {
            int op = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());

            for (int i = 1; i*p < dic; i++)
            {
                if(((i-c)*d)<(i*p))
                {
                }
                else
                {
                     op++;
                    int iop = i * p;
                    int iopd = iop / d;

                    c = i + iopd+f;

                }
            }
            Console.WriteLine(op);
        }
    }
}

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

namespace Dragon
{
    class Program
    {
        static void Main(string[] args)
        {
            int op = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());

            for (int i = 1; i*p < dic; i++)
            {
                if(((i-c)*d)>=(i*p)|| (((i+1) - c) * d) > ((i+1) * p))
                {
                    op++;
                    int iop = i * p;
                    int iopd = iop / d;

                    c = i + iopd + f;

                }
                else
                {

                }
            }
            Console.WriteLine(op);
        }
    }
}

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

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

            int coins = 0;
            int vp = int.Parse(Console.ReadLine());
            int vd = int.Parse(Console.ReadLine());
            int t = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());

            if ((vp * (t + 1)) < (vd))
            {
                int y = (vd - (vp + t)) / vp;
                coins++;
                t = t + f;
            }
            for (int i = 1; i * vp < d; i++)
            {
                if (((i - t) * vd) >= (i * vp))
                {
                    coins++;
                    int iop = i * vp;
                    int iopd = iop / vd;
                    t = i + iopd + f;
                }
            }
            Console.WriteLine(coins);
        }
    }
}

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

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

            int opp = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());
            //int p = 2;
            //int d = 7;
            //int c = 1;
            //int f = 1;
            //int dic = 26;

            int y = c;
            for (int i = y; i * p < dic; i++)
            {
                if (((i - c) * d) >= (i * p))
                {
                    opp++;
                    int iop = i * p;
                    int iopd = iop / d;
                    c = i + iopd + f;
                }
                else
                {
                    if( (p*(c+1))<(d))
                    {
                        opp++;

                        c += f;
                    }
                }
            }
            Console.WriteLine(opp);
        }
    }
}

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

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

            int opp = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());
            //int p = 2;
            //int d = 7;
            //int c = 1;
            //int f = 1;
            //int dic = 26;

            int y = c;
            for (int i = y+1; i * p < dic; i++)
            {
                if (((i - c) * d) >= (i * p))
                {
                    if ((p * (c + 1)) < (d))
                    {
                        opp++;

                    }
                    else
                    {
                        opp++;
                        int iop = i * p;
                        int iopd = iop / d;
                        c = i + iopd + f;
                    }

                }
                else
                {

                }
            }
            Console.WriteLine(opp);
        }
    }
}

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

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

            int opp = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());
            //int p = 2;
            //int d = 7;
            //int c = 1;
            //int f = 1;
            //int dic = 26;

            int y = c;
            for (int i = y+1; i * p < dic; i++)
            {
                if (((i - c) * d) >= (i * p))
                {
                    opp++;
                    int iop = i * p;
                    int iopd = iop / d;
                    c = i + iopd + f;
                }
                else
                {
                    if( (p*(c+1))<(d))
                    {
                        opp++;

                        c += f;
                    }
                }
            }
            Console.WriteLine(opp);
        }
    }
}

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

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

            int coins = 0;
            int vp = int.Parse(Console.ReadLine());
            int vd = int.Parse(Console.ReadLine());
            int t = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());

            if ((vp * (t + 1)) < (vd))
            {
                int y = (vd - (vp + t)) / vp;
                coins++;
                t = t + f;
            }
            for (int i = 1; i * vp < d; i++)
            {
                if (((i - t) * vd) >= (i * vp))
                {
                    coins++;
                    int iop = i * vp;
                    int iopd = iop / vd;
                    t = i + iopd + f;
                }
           else
                {
                    if(coins==0&&(i*vp)>(d*(i-t))&&i>1)
                    {
                        coins++;
                        int iop = i * vp;
                        int iopd = iop / vd;
                        t = i + iopd + f;
                    }
                }
            }
            Console.WriteLine(coins);
        }
    }
}

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

namespace Dragon
{
    class Program
    {
        static void Main(string[] args)
        {
            int opp = 0;
            int p = 3;
            int d = 7;
            int c = 1;
            int f = 1;
            int dic = 12;

            for (int i = 1; i * p < dic; i++)
            {
                if (((i - c) * d) >= (i * p) || (d - f) > p)
                {
                    opp++;
                    int iop = i * p;
                    int iopd = iop / d;
                    //if(iopd==0)
                    //{ iopd = 1; }
                    c = i + iopd + f;
                    i = c;

                }
                else
                {

                }
            }
            Console.WriteLine(opp);
        }
    }
}

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

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

            int opp = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());
            //int p = 2;
            //int d = 7;
            //int c = 1;
            //int f = 1;
            //int dic = 26;

            for (int i = 1; i * p < dic; i++)
            {
                if (((i - c) * d) >= (i * p))
                {
                    opp++;
                    int iop = i * p;
                    int iopd = iop / d;
                    c = i + iopd + f;
                }

            }
            Console.WriteLine(opp);
        }
    }
}

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

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

            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());

            int rp = (dic - c) / p;
            int rd = dic / d;
            double rpd = (double)(rp - rd) / (2 * f);
            int re = (int)rpd;
            int ree = (rp - rd) % (2 * f);
            if(ree >(.5*(2*f)))
            {
                re = re + 1;
            }
            Console.WriteLine(re);
        }
    }
}

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

namespace Dragon
{
    class Program
    {
        static void Main(string[] args)
        {
            int opp = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());

            for (int i = 1; i*p < dic; i++)
            {
                if(((i-c)*d)>=(i*p)||(d-c)>p)
                {
                    opp++;
                    int iop = i * p;
                    int iopd = iop / d;

                    c = i + iopd + f;

                }
                else
                {

                }
            }
            Console.WriteLine(opp);
        }
    }
}

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

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

            int coins = 0;
            int vp = int.Parse(Console.ReadLine());
            int vd = int.Parse(Console.ReadLine());
            int t = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());

            while (true)
            {
                double m = t * vp;
                double n = m / (vd - vp);
                double di = n * vd;
                if(di<d&&vp<vd)
                {
                    double i = di / vp;
                    double ii = di / vd;
                    t = (int)(i + f + ii);
                    coins++;
                }
               else
                {
                    break;
                }
            }

            Console.WriteLine(coins);
        }
    }
}

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

namespace Dragon
{
    class Program
    {
        static void Main(string[] args)
        {
            int op = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());

            for (int i = 1; i < (dic/p); i++)
            {
                if(((i-c)*d)<(i*p))
                {
                }
                else
                {
                        op++;

                    int yy = ((i * p) / d) + f;
                    c = i + yy;
                }
            }
            Console.WriteLine(op);
        }
    }
}

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

namespace Dragon
{
    class Program
    {
        static void Main(string[] args)
        {
            int opp = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());

            for (int i = 1; i * p < dic; i++)
            {
                if (((i - c) * d) >= (i * p) || (d - f) > p)
                {
                    opp++;
                    int iop = i * p;
                    int iopd = iop / d;
                    if (iopd == 0)
                    { iopd = 1; }
                    c = i + iopd + f;

                }
                else
                {

                }
            }
            Console.WriteLine(opp);
        }
    }
}

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

namespace Dragon
{
    class Program
    {
        static void Main(string[] args)
        {
            int op = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());

            for (int i = 1; i*p < dic; i++)
            {
                if(((i-c)*d)>=(i*p))
                {
                    op++;
                    int iop = i * p;
                    int iopd = iop / d;

                    c = i + iopd + f;

                }
                else
                {

                }
            }
            Console.WriteLine(op);
        }
    }
}

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

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

            int opp = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());
            //int p = 2;
            //int d = 7;
            //int c = 1;
            //int f = 1;
            //int dic = 26;

            for (int i = 1; i * p < dic; i++)
            {
                if (((i - c) * d) >= (i * p))
                {
                    opp++;
                    int iop = i * p;
                    int iopd = iop / d;
                    c = i + iopd + f;
                }
                else
                {
                    if( (p*(c+1))<(d)&&i==1)
                    {
                        opp++;
                        c++;
                    }
                }
            }
            Console.WriteLine(opp);
        }
    }
}

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

namespace Dragon
{
    class Program
    {
        static void Main(string[] args)
        {
            int pp = 5;
            int opp = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());
            //int p = 2;
            //int d = 7;
            //int c = 1;
            //int f = 1;
            //int dic = 26;

            for (int i = 1; i * p < dic; i++)
            {
                if (((i - c) * d) >= (i * p))
                {
                    opp++;
                    int iop = i * p;
                    int iopd = iop / d;
                    c = i + iopd + f;
                }
                else
                {
                    if( (p*(c+1))<(d))
                    {
                        opp++;
                        if (pp == 5)
                            pp = 3;
                        else
                        c += f;
                    }
                }
            }
            Console.WriteLine(opp);
        }
    }
}

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

namespace Dragon
{
    class Program
    {
        static void Main(string[] args)
        {
            int opp = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());
            //int p = 2;
            //int d = 7;
            //int c = 1;
            //int f = 1;
            //int dic = 22;

            for (int i = 1; i * p < dic; i++)
            {
                if (((i - c) * d) >= (i * p))
                {
                    opp++;
                    int iop = i * p;
                    int iopd = iop / d;
                    c = i + iopd + f;
                }
                else
                {
                    if( (p*(c+1))<(d))
                    {
                        opp++;
                        c += f;
                    }
                }
            }
            Console.WriteLine(opp);
        }
    }
}

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

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

            int opp = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());
            //int p = 2;
            //int d = 7;
            //int c = 1;
            //int f = 1;
            //int dic = 26;

            for (int i = 1; i * p < dic; i++)
            {
                if (((i - c) * d) >= (i * p))
                {
                    opp++;
                    int iop = i * p;
                    int iopd = iop / d;
                    c = i + iopd + f;
                }
                else
                {
                    if( (p*(c+1))<(d))
                    {
                        opp++;
                        c=c+f;
                    }
                }
            }
            Console.WriteLine(opp);
        }
    }
}

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

namespace Dragon
{
    class Program
    {
        static void Main(string[] args)
        {
            int opp = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());

            for (int i = 1; i*p < dic; i++)
            {
                if(((i-c)*d)>=(i*p))
                {
                    opp++;
                    int iop = i * p;
                    int iopd = iop / d;

                    c = i + iopd + f;

                }
                else
                {

                }
            }
            Console.WriteLine(opp);
        }
    }
}

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

namespace Dragon
{
    class Program
    {
        static void Main(string[] args)
        {
            int op = 0;
            int p = int.Parse(Console.ReadLine());
            int d = int.Parse(Console.ReadLine());
            int c = int.Parse(Console.ReadLine());
            int f = int.Parse(Console.ReadLine());
            int dic = int.Parse(Console.ReadLine());
            double n = (double)d / p;
            for (int i = 1; i < 1000; i++)
            {
                if (((c*p) + i) / (n * i) >= 1)
                {
                    if (i + c >= dic)
                    {
                        break;
                    }
                }
                else
                {
                    op++;
                    c = (((i / d) + f) + (i));
                }
            }
            Console.WriteLine(op);
        }
    }
}

using System;

namespace Olymp
{
    class Program
    {
        static void Main(string[] args)
        {
            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            string vp = "1", vd = "2", t = "1", f = "1", c = "8";
            sw.Reset();
            int res;
            sw.Start();
            res = Money(vp, vd, t, f, c);
            sw.Stop();
            Console.WriteLine("{0}, {1}", res, sw.Elapsed);
            Console.ReadLine();
        }

        static public int Money(string vp1, string vd1, string t1, string f1, string c1)
        {
            int vp = Int32.Parse(vp1);
            int vd = Int32.Parse(vd1);
            int t = Int32.Parse(t1);
            int c = Int32.Parse(c1);
            int number = 0;
            int S = 0;
            while (S < c)
            {
                S += (-vd) * vp * t / (vp - vd); // ГАИ догонят Васю на расстоянии S
                if (S < c)
                    number++;
                // S/vd + f потратят на возврат и разделение
                t = S / vd * 2 + Int32.Parse(f1);
            }
            return number;
        }

    }
}

using System;

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

            string vp = Console.ReadLine();
            string vd = Console.ReadLine();
            string t = Console.ReadLine();
            string f = Console.ReadLine();
            string c = Console.ReadLine();

            Console.WriteLine(Money(vp, vd, t, f, c));
        }

        static public int Money(string vp1, string vd1, string t1, string f1, string c1)
        {
            int vp = Int32.Parse(vp1);
            int vd = Int32.Parse(vd1);
            int t = Int32.Parse(t1);
            int c = Int32.Parse(c1);
            int number = 0;
            int time = 0, allTime = c / vp, s = 0;
            while (time < allTime)
            {
                time += vd * t / (vd - vp); // ГАИ догонят Васю через время..
                if (time < allTime)
                    number++;
                // S/vd + f потратят на возврат и разделение
                s = time * vp;
                t = s/ vd * 2 + Int32.Parse(f1);
            }
            return number;
        }

    }
}

using System;

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

            string vp = Console.ReadLine();
            string vd = Console.ReadLine();
            string t = Console.ReadLine();
            string f = Console.ReadLine();
            string c = Console.ReadLine();

            Console.WriteLine(Money(vp, vd, t, f, c));
        }

        static public int Money(string vp1, string vd1, string t1, string f1, string c1)
        {
            int vp = Int32.Parse(vp1);
            int vd = Int32.Parse(vd1);
            double t = Int32.Parse(t1);
            int c = Int32.Parse(c1);
            int number = 0;
            double time = 0, allTime = c / vp, s = 0;
            while (s < c)
            {
                s += vd * t / (vd - vp)* vp;
                t = s/ vd * 2 + Double.Parse(f1);
                if (s < c)
                    number++;
            }
            return number;
        }

    }
}

using System;

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

            string vp = Console.ReadLine();
            string vd = Console.ReadLine();
            string t = Console.ReadLine();
            string f = Console.ReadLine();
            string c = Console.ReadLine();

            Console.WriteLine(Money(vp, vd, t, f, c));
        }

        static public int Money(string vp1, string vd1, string t1, string f1, string c1)
        {
            int vp = Int32.Parse(vp1);
            int vd = Int32.Parse(vd1);
            int t = Int32.Parse(t1);
            int c = Int32.Parse(c1);
            int number = 0;
            int time = 0, allTime = c / vp;
            while (time < allTime)
            {
                time += vp * t / (vd - vp); // ГАИ догонят Васю через время..
                if (time < allTime)
                    number++;
                // S/vd + f потратят на возврат и разделение
                t = time * 2 + Int32.Parse(f1);
            }
            return number;
        }

    }
}

using System;

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

            string vp = Console.ReadLine();
            string vd = Console.ReadLine();
            string t = Console.ReadLine();
            string f = Console.ReadLine();
            string c = Console.ReadLine();
            int res;
            res = Money(vp, vd, t, f, c);
            Console.WriteLine(res);

        }

        static public int Money(string vp1, string vd1, string t1, string f1, string c1)
        {
            int vp = Int32.Parse(vp1);
            int vd = Int32.Parse(vd1);
            int t = Int32.Parse(t1);
            int c = Int32.Parse(c1);
            int number = 0;
            int S = 0;
            while (S < c)
            {
                S += (-vd) * vp * t / (vp - vd); // ГАИ догонят Васю на расстоянии S
                if (S < c)
                    number++;
                // S/vd + f потратят на возврат и разделение
                t = S / vd * 2 + Int32.Parse(f1);
            }
            return number;
        }

    }
}

using System;

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

            string vp = Console.ReadLine();
            string vd = Console.ReadLine();
            string t = Console.ReadLine();
            string f = Console.ReadLine();
            string c = Console.ReadLine();

            Console.WriteLine(Money(vp, vd, t, f, c));
        }

        static public int Money(string vp1, string vd1, string t1, string f1, string c1)
        {
            int vp = Int32.Parse(vp1);
            int vd = Int32.Parse(vd1);
            int t = Int32.Parse(t1);
            int c = Int32.Parse(c1);
            int number = 0;
            int S = 0;
            while (S < c)
            {
                S += (-vd) * vp * t / (vp - vd); // ГАИ догонят Васю на расстоянии S
                if (S < c)
                    number++;
                // S/vd + f потратят на возврат и разделение
                t = S / vd * 2 + Int32.Parse(f1);
            }
            return number;
        }

    }
}

using System;

namespace ConsoleApplication1
{
    class MainClass
    {
        public static void Main(string[] args)
        {
            string n = Console.ReadLine();

            Console.WriteLine(Type(n));

        }
        static public string Type(string number)
        {
            string res = "";
            try
            {
                Int64 c = Convert.ToInt64(number);
                if (c >= -128 && c <= 127) res = "byte";
                else if (c >= -32768 && c <= 32767) res = "short";
                else if (c >= -2147483648 && c <= 2147483647) res = "int";
                else if (c >= -9223372036854775808 && c <= 9223372036854775807) res = "long";
                return res;
            }
            catch (OverflowException)
            {
                return "BigInteger";
            }

        }
    }
}