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

    }
}

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

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

#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.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.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;

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

        }
    }
}