Problem:
Score : 200 points

Problem Statement

Two children are playing tag on a number line. (In the game of tag, the child called "it" tries to catch the other child.) The child who is "it" is now at coordinate A, and he can travel the distance of V per second.
The other child is now at coordinate B, and she can travel the distance of W per second.

He can catch her when his coordinate is the same as hers.
Determine whether he can catch her within T seconds (including exactly T seconds later).
We assume that both children move optimally.

Constraints

-10^9 \leq A,B \leq 10^9

1 \leq V,W \leq 10^9

1 \leq T \leq 10^9

A \neq B

All values in input are integers.

Input

Input is given from Standard Input in the following format:

A V
B W
T

Output

If "it" can catch the other child, print YES; otherwise, print NO.

Sample Input 1

1 2
3 1
3

Sample Output 1

YES

Sample Input 2

1 2
3 2
3

Sample Output 2

NO

Sample Input 3

1 2
3 3
3

Sample Output 3

NO

Solution in C# (Mono-mcs 6.8.0.105) (judge verdict: Accepted)

/*********************************************
* c# template
* 
*********************************************/
/*********************************************
20.07.10 東京海上日動 コンテスト2020. B - Tag

直線上の二人が一定距離だけを動くことができる時、
逃げている一人を残りの一人が捕まえることができるのかを判断。

*********************************************/

namespace temp_name
{
    using System;
    using System.Linq;
    using System.Collections.Generic;
    using System.Reflection;
    using System.Text;
    using static System.Console;
    using static IOmacro.CsharpInput; 
    using static IOmacro.CppInput;

    public class Run
    {
        private struct Stat
        {
            public int pos;
            public int spd;
        }
        
        Stat chaser, runner;
        int numQry;
        
        private void init()
        {
            chaser = new Stat{pos = cin, spd = cin};
            runner = new Stat{pos = cin, spd = cin};
            numQry = cin;
            
        }
        
        private void proc()
        {
            if (runner.spd >= chaser.spd) {
                WriteLine("NO");
                return;
            }
            
            var finalDist = Math.Abs(chaser.spd - runner.spd) * numQry;
            if (finalDist - Math.Abs(chaser.pos - runner.pos) >= 0) {
                WriteLine("YES");
            }
            else {
                WriteLine("NO");
            }
        }
        
        public void work()
        {
            init();
            proc();
        }
        
    }
}

class program
{
    static void Main()
    {
        var run = new temp_name.Run();
        run.work();
    }
}


namespace IOmacro
{
    //20.06.29 수정
    
    using System; 
    using System.Linq; 
    using System.IO;
    using System.Collections.Generic;
    
    public class CsharpInput 
    {
        public static StreamWriter _writer = new StreamWriter(Console.OpenStandardOutput());
        public const char separator = ' ';
        public static string _string{get{return Console.ReadLine();}}
        public static string[] _stringa{get{return (Console.ReadLine().Split(separator));}}
        public static int _int{get{return int.Parse(Console.ReadLine());}}
        public static int[] _inta{get{return Console.ReadLine().Split(separator).Select(int.Parse).ToArray();}}
        public static long _long{get{return long.Parse(Console.ReadLine());}}
        public static long[] _longa{get{return Console.ReadLine().Split(separator).Select(long.Parse).ToArray();}}    
        public static double _double{get{return double.Parse(Console.ReadLine());}}
        public static double[] _doublea{get{return Console.ReadLine().Split(separator).Select(double.Parse).ToArray();}}    
    }
    
    public class CppInput 
    {
        public static CppInput cin => new CppInput();
        public const char separator = ' ';
        private static readonly Queue<string> _input = new Queue<string>();
        private CppInput(){}
        public static implicit operator string(CppInput _) {
            if (_input.Count == 0) Console.ReadLine().Split(separator).foreachExtension(x => _input.Enqueue(x));
            return _input.Dequeue();
        }
        public static implicit operator int(CppInput _){
            if (_input.Count == 0) Console.ReadLine().Split(separator).foreachExtension(x => _input.Enqueue(x));
            return int.Parse(_input.Dequeue());
        }
        public static implicit operator long(CppInput _){
            if (_input.Count == 0) Console.ReadLine().Split(separator).foreachExtension(x => _input.Enqueue(x));
            return long.Parse(_input.Dequeue());
        }
        public static implicit operator double(CppInput _){
            if (_input.Count == 0) Console.ReadLine().Split(separator).foreachExtension(x => _input.Enqueue(x));
            return double.Parse(_input.Dequeue());
        }
    }
    
    public static class CEnumerableExtension 
    {
        public delegate void Function<in T>(T val);
        public static void foreachExtension<T>(this IEnumerable<T> enumerable, Function<T> function) {
            foreach (var x in enumerable) function(x);
        }
    }
}