Captain Bill the Hummingbird and his crew recieved an interesting challenge offer. Some stranger gave them a map, potion of teleportation and said that only this potion might help them to reach the treasure. Bottle with potion has two values x and y written on it. These values define four moves which can be performed using the potion:         Map shows that the position of Captain Bill the Hummingbird is (x1, y1) and the position of the treasure is (x2, y2).You task is to tell Captain Bill the Hummingbird whether he should accept this challenge or decline. If it is possible for Captain to reach the treasure using the potion then output "YES", otherwise "NO" (without quotes).The potion can be used infinite amount of times.

The first line contains four integer numbers x1, y1, x2, y2 ( - 105 ≤ x1, y1, x2, y2 ≤ 105) — positions of Captain Bill the Hummingbird and treasure respectively. The second line contains two integer numbers x, y (1 ≤ x, y ≤ 105) — values on the potion bottle.

Print "YES" if it is possible for Captain to reach the treasure using the potion, otherwise print "NO" (without quotes).

NoteIn the first example there exists such sequence of moves:   — the first type of move   — the third type of move

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

namespace CF
{
	internal class Program
	{
		private static void Main(string[] args)
		{
			var sr = new InputReader(Console.In);
			//var sr = new InputReader(new StreamReader("input.txt"));
			var task = new Task();
			using (var sw = Console.Out)
			{
				//using (var sw = new StreamWriter("output.txt")) {
				task.Solve(sr, sw);
				//Console.ReadKey();
			}
		}
	}

	internal class Task
	{
		public void Solve(InputReader sr, TextWriter sw)
		{
			var input = sr.ReadArrayOfInt32();
			var x1 = input[0];
			var y1 = input[1];
			var x2 = input[2];
			var y2 = input[3];
			input = sr.ReadArrayOfInt32();
			var x = input[0];
			var y = input[1];
			var dx = Math.Abs(x2 - x1);
			var dy = Math.Abs(y2 - y1);
			var rx = dx / x;
			if (dx % x != 0)
			{
				sw.WriteLine("NO");
				return;
			}
			var ry = dy / y;
			if (dy % y != 0)
			{
				sw.WriteLine("NO");
				return;
			}
			//if (rx == 0 || ry == 0)
			//{
			//	sw.WriteLine("YES");
			//	return;
			//}
			if (Math.Abs(rx - ry) % 2 == 0) {
				sw.WriteLine("YES");
				return;
			}

			sw.WriteLine("NO");
		}
	}
}

internal class InputReader : IDisposable
{
	private bool isDispose;
	private readonly TextReader sr;

	public InputReader(TextReader stream)
	{
		sr = stream;
	}

	public void Dispose()
	{
		Dispose(true);
		GC.SuppressFinalize(this);
	}

	public string NextString()
	{
		var result = sr.ReadLine();
		return result;
	}

	public int NextInt32()
	{
		return Int32.Parse(NextString());
	}

	public long NextInt64()
	{
		return Int64.Parse(NextString());
	}

	public string[] NextSplitStrings()
	{
		return NextString()
										.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
	}

	public T[] ReadArray<T>(Func<string, CultureInfo, T> func)
	{
		return NextSplitStrings()
										.Select(s => func(s, CultureInfo.InvariantCulture))
										.ToArray();
	}

	public int[] ReadArrayOfInt32()
	{
		return ReadArray(Int32.Parse);
	}

	public long[] ReadArrayOfInt64()
	{
		return ReadArray(Int64.Parse);
	}

	public T[] ReadArrayFromString<T>(Func<string, CultureInfo, T> func, string str)
	{
		return
										str.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
																		.Select(s => func(s, CultureInfo.InvariantCulture))
																		.ToArray();
	}

	protected void Dispose(bool dispose)
	{
		if (!isDispose)
		{
			if (dispose)
				sr.Close();
			isDispose = true;
		}
	}

	~InputReader()
	{
		Dispose(false);
	}
}

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

namespace Chloe_and_the_Sequence
{
    class Program
    {
        static void Main(string[] args)
        {
            int x1, y1, x2, y2, x3, y3;
            string[] input = Console.ReadLine().Split(' ');
            x1 = int.Parse(input[0]);
            y1 = int.Parse(input[1]);
            x2 = int.Parse(input[2]);
            y2 = int.Parse(input[3]);
            string[] input2 = Console.ReadLine().Split(' ');
            x3 = int.Parse(input2[0]);
            y3 = int.Parse(input2[1]);
            if (Math.Abs(x2 - x1) % x3 == 0 && Math.Abs(y2 - y1) % y3 == 0 && Math.Abs(Math.Abs(x2 - x1) / x3 - Math.Abs(y2 - y1) / y3) % 2 == 0)
                Console.WriteLine("Yes");
            else
                Console.WriteLine("No");
        }
    }
}

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

namespace ConsoleApplication1.CodeForces
{
    class _4032
    {
        private static int Next()
        {
            int c;
            int res = 0;
            do
            {
                c = reader.Read();
                if (c == -1)
                    return res;
            } while (c < '0' || c > '9');
            res = c - '0';
            while (true)
            {
                c = reader.Read();
                if (c < '0' || c > '9')
                    return res;
                res *= 10;
                res += c - '0';
            }
        }
        private static readonly StreamReader reader = new StreamReader(Console.OpenStandardInput(1024 * 10), Encoding.ASCII, false, 1024 * 10);
        private static readonly StreamWriter writer = new StreamWriter(Console.OpenStandardOutput(1024 * 10), Encoding.ASCII, 1024 * 10);

        class Node : IComparable
        {
            public long X { get; set; }
            public long Y { get; set; }
            public int CompareTo(object obj)
            {
                if (this.Y > ((Node)obj).Y)
                {
                    return 1;
                }
                if (this.Y == ((Node)obj).Y)
                {
                    return 0;
                }
                return -1;
            }
        }

        static void Main(String[] args)
        {
            var data = Console.ReadLine().TrimEnd().Split(' ').Select(double.Parse).ToList();
            var x1 = data[0];
            var y1 = data[1];
            var x2 = data[2];
            var y2 = data[3];
            data = Console.ReadLine().TrimEnd().Split(' ').Select(double.Parse).ToList();
            var x = data[0];
            var y = data[1];

            for (var i = 0; i < 100000 * 5; i++)
            {
                if (x2 > x1)
                {
                    x1 += x;
                }
                else
                {
                    x1 -= x;
                }

                if (y2 > y1)
                {
                    y1 += y;
                }
                else
                {
                    y1 -= y;
                }

                if (y1 == y2 && x1 == x2)
                {
                    Console.WriteLine("YES");
                    return;
                }
            }
            Console.WriteLine("NO");
        }

    }
}

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

namespace HayCragrer
{
    class Problem4
    {
        static void Main(string[] args)
        {
            int[] coords = new int[4];
            string[] text = Console.ReadLine().Split();
            string[] text1 = Console.ReadLine().Split();
            int[] steps = new int[2];
            for (int i = 0; i < 4; i++)
            {
                coords[i] = int.Parse(text[i]);
            }
            for (int i = 0; i < 2; i++)
            {
                steps[i] = int.Parse(text1[i]);
            }
            int x = coords[2] - coords[0];
            int y = coords[3] - coords[1];
            if ((x % steps[0] == 0) && (y % steps[1] == 0))
            {
                if ((x / steps[0] -y / steps[1]) % 2==0)
                {
                    Console.WriteLine("YES");
                }
                else
                {
                    Console.WriteLine("NO");
                }

            }
            else
            {
                Console.WriteLine("NO");
            }
        }
    }
}

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

namespace Codeforces
{
    class P817A
    {
        static void Main(string[] args)
        {
            string[] input1 = Console.ReadLine().Split();
            int x1 = int.Parse(input1[0]);
            int y1 = int.Parse(input1[1]);
            int x2 = int.Parse(input1[2]);
            int y2 = int.Parse(input1[3]);
            string[] input2 = Console.ReadLine().Split();
            int x = int.Parse(input2[0]);
            int y = int.Parse(input2[1]);
            Console.WriteLine((Math.Abs(x1 - x2) % x == 0 && Math.Abs(y1 - y2) % y == 0 && (Math.Abs(x1 - x2) / x) % 2 == (Math.Abs(y1 - y2) / y) % 2) ? "YES" : "NO");
        }
    }
}

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

namespace Achill
{
    class Program
    {
        static void Main(string[] args)
        {
            List<double> cord = Console.ReadLine().Split().Select(item=>double.Parse(item)).ToList();
            List<double> step = Console.ReadLine().Split().Select(item=>double.Parse(item)).ToList();
            Func<double, double> LeftO = y1 => (y1 - cord[1]) / step[1];
            double y = 0.5 * step[1] * ((cord[2] - cord[0])/step[0] + (cord[1]  + cord[3]) / step[1]);
            double x = LeftO(y) * step[0] + cord[0];
            bool res = Math.Truncate(x) == x && Math.Truncate(y) == y;
            if (res)
            {
                res = (Math.Abs(x-cord[0])%step[0] == 0) && (Math.Abs(y - cord[1]) % step[1] == 0);
                res = res && (Math.Abs(x - cord[2]) % step[0] == 0) && (Math.Abs(y - cord[3]) % step[1] == 0);
            }
            Console.WriteLine(res ? "YES" : "NO");
        }
    }
}

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

class Program
{
    static void Main()
    {
        new Magatro().Solve();
    }
}

class Magatro
{
    private int XOne, YOne, XTwo, YTwo, X, Y;
    private void Scan()
    {
        var line = Console.ReadLine().Split(' ');
        XOne = int.Parse(line[0]);
        YOne = int.Parse(line[1]);
        XTwo = int.Parse(line[2]);
        YTwo = int.Parse(line[3]);
        line = Console.ReadLine().Split(' ');
        X = int.Parse(line[0]);
        Y = int.Parse(line[1]);
    }

    public void Solve()
    {
        Scan();
        int xDist = Math.Abs(XTwo - XOne);
        int yDist = Math.Abs(YTwo - YOne);
        if ((xDist % X != 0)||(yDist%Y!=0))
        {
            Console.WriteLine("NO");
            return;
        }
        int xx = xDist / X;
        int yy = yDist / Y;
        if (xx % 2 == yy % 2)
        {
            Console.WriteLine("YES");
        }
        else
        {
            Console.WriteLine("NO");
        }
    }
}

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

class Program
{
    static void Main()
    {
        new Magatro().Solve();
    }
}

class Magatro
{
    private int X1, Y1, X2, Y2, X, Y;
    private void Scan()
    {
        var line = Console.ReadLine().Split(' ');
        X1 = int.Parse(line[0]);
        Y1 = int.Parse(line[1]);
        X2 = int.Parse(line[2]);
        Y2 = int.Parse(line[3]);
        line = Console.ReadLine().Split(' ');
        X = int.Parse(line[0]);
        Y = int.Parse(line[1]);
    }

    public void Solve()
    {
        Scan();
        int xDist = Math.Abs(X2 - X1);
        int yDist = Math.Abs(Y2 - Y1);
        if ((xDist % X != 0)||(yDist%Y!=0))
        {
            Console.WriteLine("NO");
            return;
        }
        int xx = xDist / X;
        int yy = yDist / Y;
        if (xx % 2 == yy % 2)
        {
            Console.WriteLine("YES");
        }
        else
        {
            Console.WriteLine("NO");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Runtime.CompilerServices;
using System.Text;
using System.Diagnostics;
using System.Numerics;
using static System.Console;
using static System.Convert;
using static System.Math;
using static Template;
using Pi = Pair<int, int>;

class Solver
{
    public void Solve(Scanner sc)
    {
        int x1, y1, x2, y2,x,y;
        sc.Make(out x1, out y1, out x2, out y2, out x, out y);
        if (Abs(x2 - x1) % x != 0 || Abs(y2 - y1) % y != 0) Fail("NO");
        var a = Abs(x2 - x1) / x;
        var b = Abs(y2 - y1) / y;
        if (a % 2 == b % 2) Fail("YES");
        Console.WriteLine("NO");
    }
}

#region Template
public static class Template
{
    static void Main(string[] args)
    {
        Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        new Solver().Solve(new Scanner());
        Console.Out.Flush();
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool chmin<T>(ref T a, T b) where T : IComparable<T> { if (a.CompareTo(b) > 0) { a = b; return true; } return false; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool chmax<T>(ref T a, T b) where T : IComparable<T> { if (a.CompareTo(b) < 0) { a = b; return true; } return false; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void swap<T>(ref T a, ref T b) { var t = b; b = a; a = t; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void swap<T>(this IList<T> A, int i, int j) { var t = A[i]; A[i] = A[j]; A[j] = t; }
    public static T[] Create<T>(int n, Func<T> f) { var rt = new T[n]; for (var i = 0; i < rt.Length; ++i) rt[i] = f(); return rt; }
    public static T[] Create<T>(int n, Func<int, T> f) { var rt = new T[n]; for (var i = 0; i < rt.Length; ++i) rt[i] = f(i); return rt; }
    public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> A) => A.OrderBy(v => Guid.NewGuid());
    public static int CompareTo<T>(this T[] A, T[] B, Comparison<T> cmp = null) { cmp = cmp ?? Comparer<T>.Default.Compare; for (var i = 0; i < Min(A.Length, B.Length); i++) { int c = cmp(A[i], B[i]); if (c > 0) return 1; else if (c < 0) return -1; } if (A.Length == B.Length) return 0; if (A.Length > B.Length) return 1; else return -1; }
    public static int MaxElement<T>(this IList<T> A, Comparison<T> cmp = null) { cmp = cmp ?? Comparer<T>.Default.Compare; T max = A[0]; int rt = 0; for (int i = 1; i < A.Count; i++) if (cmp(max, A[i]) < 0) { max = A[i]; rt = i; } return rt; }
    public static T PopBack<T>(this List<T> A) { var v = A[A.Count - 1]; A.RemoveAt(A.Count - 1); return v; }
    public static void Fail<T>(T s) { Console.WriteLine(s); Console.Out.Close(); Environment.Exit(0); }
}
public class Scanner
{
    public string Str => Console.ReadLine().Trim();
    public int Int => int.Parse(Str);
    public long Long => long.Parse(Str);
    public double Double => double.Parse(Str);
    public int[] ArrInt => Str.Split(' ').Select(int.Parse).ToArray();
    public long[] ArrLong => Str.Split(' ').Select(long.Parse).ToArray();
    public char[][] Grid(int n) => Create(n, () => Str.ToCharArray());
    public int[] ArrInt1D(int n) => Create(n, () => Int);
    public long[] ArrLong1D(int n) => Create(n, () => Long);
    public int[][] ArrInt2D(int n) => Create(n, () => ArrInt);
    public long[][] ArrLong2D(int n) => Create(n, () => ArrLong);
    private Queue<string> q = new Queue<string>();
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public T Next<T>() { if (q.Count == 0) foreach (var item in Str.Split(' ')) q.Enqueue(item); return (T)Convert.ChangeType(q.Dequeue(), typeof(T)); }
    public void Make<T1>(out T1 v1) => v1 = Next<T1>();
    public void Make<T1, T2>(out T1 v1, out T2 v2) { v1 = Next<T1>(); v2 = Next<T2>(); }
    public void Make<T1, T2, T3>(out T1 v1, out T2 v2, out T3 v3) { Make(out v1, out v2); v3 = Next<T3>(); }
    public void Make<T1, T2, T3, T4>(out T1 v1, out T2 v2, out T3 v3, out T4 v4) { Make(out v1, out v2, out v3); v4 = Next<T4>(); }
    public void Make<T1, T2, T3, T4, T5>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5) { Make(out v1, out v2, out v3, out v4); v5 = Next<T5>(); }
    public void Make<T1, T2, T3, T4, T5, T6>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5, out T6 v6) { Make(out v1, out v2, out v3, out v4, out v5); v6 = Next<T6>(); }
    public void Make<T1, T2, T3, T4, T5, T6, T7>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5, out T6 v6, out T7 v7) { Make(out v1, out v2, out v3, out v4, out v5, out v6); v7 = Next<T7>(); }
    //public (T1, T2) Make<T1, T2>() { Make(out T1 v1, out T2 v2); return (v1, v2); }
    //public (T1, T2, T3) Make<T1, T2, T3>() { Make(out T1 v1, out T2 v2, out T3 v3); return (v1, v2, v3); }
    //public (T1, T2, T3, T4) Make<T1, T2, T3, T4>() { Make(out T1 v1, out T2 v2, out T3 v3, out T4 v4); return (v1, v2, v3, v4); }
}
public class Pair<T1, T2> : IComparable<Pair<T1, T2>>
{
    public T1 v1;
    public T2 v2;
    public Pair() { }
    public Pair(T1 v1, T2 v2)
    { this.v1 = v1; this.v2 = v2; }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public int CompareTo(Pair<T1, T2> p)
    {
        var c = Comparer<T1>.Default.Compare(v1, p.v1);
        if (c == 0)
            c = Comparer<T2>.Default.Compare(v2, p.v2);
        return c;
    }
    public override string ToString() => $"{v1.ToString()} {v2.ToString()}";
    public void Deconstruct(out T1 a, out T2 b) { a = v1; b = v2; }
}

public class Pair<T1, T2, T3> : Pair<T1, T2>, IComparable<Pair<T1, T2, T3>>
{
    public T3 v3;
    public Pair() : base() { }
    public Pair(T1 v1, T2 v2, T3 v3) : base(v1, v2)
    { this.v3 = v3; }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public int CompareTo(Pair<T1, T2, T3> p)
    {
        var c = base.CompareTo(p);
        if (c == 0)
            c = Comparer<T3>.Default.Compare(v3, p.v3);
        return c;
    }
    public override string ToString() => $"{base.ToString()} {v3.ToString()}";
    public void Deconstruct(out T1 a, out T2 b, out T3 c) { Deconstruct(out a, out b); c = v3; }
}
#endregion

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

namespace CodeForces
{
   class ADiv2
   {
      static void Main(string[] args)
      {
            string[] token = Console.ReadLine().Split();
            int x1 = int.Parse(token[0]);
            int y1 = int.Parse(token[1]);
            int x2 = int.Parse(token[2]);
            int y2 = int.Parse(token[3]);

            string[] token2 = Console.ReadLine().Split();
            int x  = int.Parse(token2[0]);
            int y  = int.Parse(token2[1]);

            int xDis = Math.Abs(x2-x1);
            int yDis = Math.Abs(y2-y1);

            if (xDis % x != 0||yDis % y!=0)
            {
              Console.WriteLine("NO");
              return;
            }
            int xx = xDis / x;
            int yy = yDis / y;
            if (xx % 2 == yy % 2)
            {
                Console.WriteLine("YES");
            }
            else
            {
                Console.WriteLine("NO");
            }
      }
   }

}

/* Date: 16.06.2017 * Time: 21:45 */

/*
�	fflush(stdout) � ����� C++;
�	System.out.flush() � Java;
�	stdout.flush() � Python;
�	flush(output) � Pascal;
*/

using System;
using System.IO;
using System.Globalization;

class Example
{
	public static void Main (string[] args)
	{
# if ( ONLINE_JUDGE )

# else
		StreamReader sr = new StreamReader ("C:\\TRR\\2017\\Task\\07 Codeforces\\024\\A.TXT");
		StreamWriter sw = new StreamWriter ("C:\\TRR\\2017\\Task\\07 Codeforces\\024\\A.OUT");
//		StreamReader sr = new StreamReader ("E:\\TRR\\20170422\\A.TXT");
//		StreamWriter sw = new StreamWriter ("E:\\TRR\\20170422\\A.OUT");
# endif

		string ss;

# if ( ONLINE_JUDGE )
		ss = Console.ReadLine ();
# else
		ss = sr.ReadLine ();
		sw.WriteLine (ss);
# endif

		string [] s = ss.Split (' ');
		int x1 = int.Parse (s [0]);
		int y1 = int.Parse (s [1]);
		int x2 = int.Parse (s [2]);
		int y2 = int.Parse (s [3]);

# if ( ONLINE_JUDGE )
		ss = Console.ReadLine ();
# else
		ss = sr.ReadLine ();
		sw.WriteLine (ss);
# endif

		string [] s0 = ss.Split (' ');
		int x = int.Parse (s0 [0]);
		int y = int.Parse (s0 [1]);

		int kx = (Math.Abs (x1 - x2)) / x;
		int ky = (Math.Abs (y1 - y2)) / y;
		bool ok = (Math.Abs (x1 - x2)) % x == 0 && (Math.Abs (y1 - y2)) % y == 0 && (Math.Abs (kx - ky)) % 2 == 0;

# if ( ONLINE_JUDGE )
		if ( ok )
			Console.WriteLine ("YES");
		else
			Console.WriteLine ("NO");
# else
		if ( ok )
			sw.WriteLine ("YES");
		else
			sw.WriteLine ("NO");
		sw.Close ();
# endif

	}
}

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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] tokens = Console.ReadLine().Split(' ');
            long x1 = int.Parse(tokens[0]);
            long x2 = int.Parse(tokens[2]);
            long y1 = int.Parse(tokens[1]);
            long y2 = int.Parse(tokens[3]);
            tokens = Console.ReadLine().Split(' ');
            long x = int.Parse(tokens[0]);
            long y = int.Parse(tokens[1]);

            long a = Math.Abs(x2 - x1);
            long b = Math.Abs(y2 - y1);

            string res;
            bool c = (a % x) == 0;
            bool d = (b % y) == 0;
            long e = (a / x) % 2;
            long f = (b / y) % 2;
            if ( c && d && ( e == f ) ) res = "YES";
            else res = "NO";

            Console.WriteLine(res);
        }
    }
}

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

namespace Treasure_Hunt
{
    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)
        {
            long x1 = Next(), y1 = Next(), x2 = Next(), y2 = Next();
            long x = Next(), y = Next();

            if (Math.Abs(x1 - x2)%x == 0 && Math.Abs(y1 - y2)%y == 0)
            {
                if ((Math.Abs(x1 - x2)/x)%2 == (Math.Abs(y1 - y2)/y)%2)
                {
                    writer.WriteLine("YES");
                    writer.Flush();
                    return;
                }
            }

            writer.WriteLine("NO");
            writer.Flush();
        }

        private static int Next()
        {
            int c;
            int m = 1;
            do
            {
                c = reader.Read();
                if (c == '-')
                    m = -1;
            } while (c < '0' || c > '9');
            int res = c - '0';
            while (true)
            {
                c = reader.Read();
                if (c < '0' || c > '9')
                    return m*res;
                res *= 10;
                res += c - '0';
            }
        }
    }
}

using System;
namespace _817A
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] input1 = Array.ConvertAll(Console.ReadLine().Split(' '), int.Parse);
            int x1 = input1[0], y1 = input1[1], x2 = input1[2], y2 = input1[3];
            int[] input2 = Array.ConvertAll(Console.ReadLine().Split(' '), int.Parse);
            int x = input2[0], y = input2[1];
            bool result = true;
            int xD = Math.Abs(x2 - x1), yD = Math.Abs(y2 - y1);
            if (xD % x != 0 || yD % y != 0)
                result = false;
            else
            {
                int xT = xD / x, yT = yD / y;
                if (xT % 2 != yT % 2)
                    result = false;
            }
            Console.WriteLine(result ? "YES" : "NO");
        }
    }
}

#region Using Statements
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

#endregion
namespace csConsoleforStudy
{
 using System.Collections.Generic;
 using System.Globalization;

 public class Printer : StreamWriter
 {
  public override IFormatProvider FormatProvider
  {
   get
   {
    return CultureInfo.InvariantCulture;
   }
  }

  public Printer(Stream stream): base (stream, new UTF8Encoding(false, true))
  {
  }

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

 class Program
 {
  static readonly Encoding TargetEcoding = Encoding.Unicode;
  static void Main(string[] args)
  {
   OpenStream();
   Solver s = new Solver();
   s.Solve();
   CloseStream();
  }

  static void OpenStream()
  {
  }

  static void CloseStream()
  {
  }

  static void CheckMemory()
  {
  }
 }

 class Solver
 {
  public static readonly Encoding TargetEncoding = Encoding.Unicode;
  const int SIZE = 5005;
  private const double AbsoluteError = 1e-10;
  private const double RelativeError = 1e-8;
  static int mod = 1000000007;
  public void Solve()
  {
   var in1 = ria();
   int fx = in1[0];
   int fy = in1[1];
   int tx = in1[2];
   int ty = in1[3];
   int targetx = tx - fx;
   int targety = ty - fy;
   var in2 = ria();
   int a = 0;
   int b = 0;
   if (targetx % in2[0] != 0 || targety % in2[1] != 0)
   {
    Console.WriteLine("NO");
    return;
   }

   a = targetx / in2[0];
   b = targety / in2[1];
   if ((a + b) % 2 == 0)
    Console.WriteLine("YES");
   else
    Console.WriteLine("NO");
  }

#region SolverUtils
  private static List<int> factorial = new List<int>(new int[]{1});
  private static int NextInt()
  {
   int c;
   int res = 0;
   do
   {
    c = Console.Read();
    if (c == -1)
     return res;
   }
   while (c < '0' || c > '9');
   res = c - '0';
   while (true)
   {
    c = Console.Read();
    if (c < '0' || c > '9')
     return res;
    res *= 10;
    res += c - '0';
   }
  }

  static string rs()
  {
   return Console.ReadLine();
  }

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

  static uint rui()
  {
   return uint.Parse(Console.ReadLine());
  }

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

  static ulong rul()
  {
   return ulong.Parse(Console.ReadLine());
  }

  static double rd()
  {
   return double.Parse(Console.ReadLine(), CultureInfo.InvariantCulture);
  }

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

  static int[] ria()
  {
   return Array.ConvertAll(Console.ReadLine().Trim(' ').Split(' '), e => int.Parse(e));
  }

  static uint[] ruia()
  {
   return Array.ConvertAll(Console.ReadLine().Trim(' ').Split(' '), e => uint.Parse(e));
  }

  static long[] rla()
  {
   return Array.ConvertAll(Console.ReadLine().Trim(' ').Split(' '), e => long.Parse(e));
  }

  static ulong[] rula()
  {
   return Array.ConvertAll(Console.ReadLine().Trim(' ').Split(' '), e => ulong.Parse(e));
  }

  static double[] rda()
  {
   return Array.ConvertAll(Console.ReadLine().Trim(' ').Split(' '), e => double.Parse(e));
  }

  static void ReadLineAndAssign(string type, params object[] p)
  {
   dynamic input;
   if (type.StartsWith("i"))
    input = ria();
   else if (type.StartsWith("l"))
    input = rla();
   else if (type.StartsWith("d"))
    input = rda();
   else
    throw new ArgumentException("no match " + type.ToString());
   for (int i = 0; i < p.Length; i++)
   {
    p[i] = input[i];
   }
  }

  static void SwapIfGreater<T>(ref T lhs, ref T rhs)where T : IComparable<T>
  {
   T temp;
   if (lhs.CompareTo(rhs) > 0)
   {
    temp = lhs;
    lhs = rhs;
    rhs = temp;
   }
  }

  static bool DoubleEqual(double a, double b)
  {
   double diff = Math.Abs(a - b);
   if (diff < AbsoluteError)
    return true;
   return diff <= RelativeError * Math.Max(Math.Abs(a), Math.Abs(b));
  }

  static dynamic abs(dynamic num)
  {
   return Math.Abs(num);
  }

  static dynamic max(dynamic a, dynamic b)
  {
   return Math.Max(a, b);
  }

  static void For(int start, int end, Action method)
  {
   for (int i = start; i < end; i++)
   {
    method.Invoke();
   }
  }

  static void For(int start, int end, Action<int> method, int i)
  {
   for (i = start; i < end; i++)
   {
    method.DynamicInvoke(i);
   }
  }

  static int C(int n, int k)
  {
   return P(n, k) / Factorial(k);
  }

  static int P(int n, int r)
  {
   return Factorial(n) / Factorial(n - r);
  }

  static int Factorial(int n)
  {
   if (factorial.Count <= n)
    factorial.Add(Factorial(n - 1) * n);
   return factorial[n];
  }

  static bool IsEven(int a)
  {
   return (a % 2) == 0;
  }

  static bool IsOdd(int a)
  {
   return !IsEven(a);
  }

  static int powmod(int a, int b)
  {
   if (b == 0)
    return 1;
   if (b == 1)
    return a;
   int i = powmod(a, b / 2);
   i *= i;
   i %= mod;
   if (b % 2 == 0)
    return i;
   else
    return ((i * a) % mod);
  }
#endregion
 }
#region SolverUtils
#endregion
#region Data Structure
#endregion
#region Algorithm
#endregion
#region Library Method/Fields
#region Members for Internal Support
#endregion Members for Internal Support
#region Public Properties
#endregion Public Properties
#region Public Instance Methods
#endregion Public Instance Methods
#region Constructors
#endregion Constructors
#region Public Static Methods
#endregion Public Static Methods
#region Operator Overloads
#endregion Operator Overloads
#region explicit conversions from BigRational
#endregion explicit conversions from BigRational
#region implicit conversions to BigRational
#endregion implicit conversions to BigRational
#region serialization
#endregion serialization
#region instance helper methods
#endregion instance helper methods
#region static helper methods
#endregion static helper methods
#region Exceptions
#endregion
#endregion
}
#region Libraries
#region operation methods
#endregion
#region Operators
#endregion
#region DataStructures
#region IComparable implementation
#endregion
#region Model
#endregion
#region Constructors
#endregion
#region Internal
#region IEqualityComparer implementation
#endregion
#endregion
#region IGraph implementation
#endregion
#region Clique invariants
#endregion
#region Clique methods
#endregion
#region IEquatable implementation
#endregion
#endregion
#region Algorithms
#endregion
#endregion

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

namespace Codeforces
{
    class Program : ProgramBase
    {
        private const long commonMod = 1000000007;

        static void Main(string[] args)
        {
            var p = new Program();
            var x = p.Solve();
            p.Out(x);
        }
        object Solve()
        {
            //var a = ReadLongs();
            //var b = a.ToList();
            //var first = b.Min();
            //b.Remove(first);
            //var sec = b.Min();
            //b.Remove(sec);
            //var third = b.Min();

            var a = ReadLongs();
            var b = ReadLongs();
            var xd = Math.Abs(a[0] - a[2]);
            var yd = Math.Abs(a[1] - a[3]);
            return xd % b[0] == 0 && yd % b[1] == 0 && (xd / b[0] + yd / b[1]) % 2 == 0 ? "YES" : "NO";
        }

        int BS(long[] a, int left, int right, long s)
        {
            if (right - left == 1)
                return left;
            var half = (left + right) / 2;
            if (Check(half, a, s))
                return BS(a, half, right, s);
            return BS(a, left, half, s);
        }

        bool Check(int k, long[] a, long s)
        {
            var newArr = new long[a.Length];
            for (int i = 0; i < a.Length; i++)
            {
                newArr[i] = a[i] + ((long)k) * (i + 1);
            }
            Array.Sort(newArr);
            return newArr.Take(k).Sum() <= s;
        }

        double Dist(Point a, Point b, Point z)
        {
            return Math.Abs((b.y - a.y) * z.x - (b.x - a.x) * z.y + b.x * a.y - b.y * a.x) / Math.Sqrt((b.y - a.y) * (b.y - a.y) + (b.x - a.x) * (b.x - a.x));
        }

    }

    class Point
    {
        public double x { get; set; }
        public double y { get; set; }
    }

    abstract class ProgramBase
    {
        bool? prod = null;
        StreamReader f;
        Queue<string> tokens;
        protected string FileName { private get; set; }

        protected string Read()
        {
            if (f == null)
                f = string.IsNullOrEmpty(FileName)
                    ? new StreamReader(Console.OpenStandardInput(1024*10), Encoding.ASCII, false, 1024 * 10)
                    : new StreamReader((GetProd() ? "" : "c:\\dev\\") + FileName);
            return f.ReadLine();
        }

        protected string ReadToken()
        {
            if (tokens == null || tokens.Count == 0)
                tokens = new Queue<string>(Read().Split(' '));
            return tokens.Dequeue();
        }

        protected long ReadLong() { return long.Parse(ReadToken()); }

        protected long[] ReadLongs()
        {
            var s = Read();
            if (s == "")
                return new long[0];
            //var i = s.IndexOf(' ');
            //return new[] { long.Parse(s.Substring(0, i)), long.Parse(s.Substring(i + 1)) };
            var tokens = s.Split(' ');
            var result = new long[tokens.Length];
            for (int i = 0; i < tokens.Length; i++)
                result[i] = long.Parse(tokens[i]);
            return result;
        }

        public void Out(object r)
        {
            if (string.IsNullOrEmpty(FileName))
                Console.WriteLine(r);
            else if (GetProd())
                File.WriteAllText(FileName, r.ToString());
            else
                Console.WriteLine(r);
        }

        private bool GetProd()
        {

            if (!prod.HasValue)
                try
                {
                    prod = Environment.MachineName != "RENADEEN-W7";
                }
                catch (Exception)
                {
                    prod = true;
                }
            return prod.Value;
        }
    }

    public static class Huj
    {
        public static T MinBy<T>(this IEnumerable<T> source, Func<T, double> func) where T : class
        {
            T result = null;
            var min = double.MaxValue;
            foreach (var item in source)
            {
                var current = func(item);
                if (min > current)
                {
                    min = current;
                    result = item;
                }
            }
            return result;
        }

        public static T MaxBy<T>(this IEnumerable<T> source, Func<T, double> func, T defaultValue = default(T))
        {
            T result = defaultValue;
            var max = double.MinValue;
            foreach (var item in source)
            {
                var current = func(item);
                if (max < current)
                {
                    max = current;
                    result = item;
                }
            }
            return result;
        }

        public static string JoinStrings(this IEnumerable<string> s, string d) { return string.Join(d, s.ToArray()); }

        public static string JoinStrings(this IEnumerable<int> s, string d) { return s.Select(x => x.ToString()).JoinStrings(d); }
        public static string JoinStrings(this IEnumerable<long> s, string d) { return s.Select(x => x.ToString()).JoinStrings(d); }
    }

}

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

namespace Codeforces
{
    class Program : ProgramBase
    {
        private const long commonMod = 1000000007;

        static void Main(string[] args)
        {
            var p = new Program();
            var x = p.Solve();
            p.Out(x);
        }
        object Solve()
        {
            var a = ReadLongs();
            var b = ReadLongs();
            var xd = Math.Abs(a[0] - a[2]);
            var yd = Math.Abs(a[1] - a[3]);
            return xd % b[0] == 0 && yd % b[1] == 0 && (xd / b[0] + yd / b[1]) % 2 == 0 ? "YES" : "NO";
        }

        int BS(long[] a, int left, int right, long s)
        {
            if (right - left == 1)
                return left;
            var half = (left + right) / 2;
            if (Check(half, a, s))
                return BS(a, half, right, s);
            return BS(a, left, half, s);
        }

        bool Check(int k, long[] a, long s)
        {
            var newArr = new long[a.Length];
            for (int i = 0; i < a.Length; i++)
            {
                newArr[i] = a[i] + ((long)k) * (i + 1);
            }
            Array.Sort(newArr);
            return newArr.Take(k).Sum() <= s;
        }

        double Dist(Point a, Point b, Point z)
        {
            return Math.Abs((b.y - a.y) * z.x - (b.x - a.x) * z.y + b.x * a.y - b.y * a.x) / Math.Sqrt((b.y - a.y) * (b.y - a.y) + (b.x - a.x) * (b.x - a.x));
        }

    }

    class Point
    {
        public double x { get; set; }
        public double y { get; set; }
    }

    abstract class ProgramBase
    {
        bool? prod = null;
        StreamReader f;
        Queue<string> tokens;
        protected string FileName { private get; set; }

        protected string Read()
        {
            if (f == null)
                f = string.IsNullOrEmpty(FileName)
                    ? new StreamReader(Console.OpenStandardInput(1024*10), Encoding.ASCII, false, 1024 * 10)
                    : new StreamReader((GetProd() ? "" : "c:\\dev\\") + FileName);
            return f.ReadLine();
        }

        protected string ReadToken()
        {
            if (tokens == null || tokens.Count == 0)
                tokens = new Queue<string>(Read().Split(' '));
            return tokens.Dequeue();
        }

        protected long ReadLong() { return long.Parse(ReadToken()); }

        protected long[] ReadLongs()
        {
            var s = Read();
            if (s == "")
                return new long[0];
            //var i = s.IndexOf(' ');
            //return new[] { long.Parse(s.Substring(0, i)), long.Parse(s.Substring(i + 1)) };
            var tokens = s.Split(' ');
            var result = new long[tokens.Length];
            for (int i = 0; i < tokens.Length; i++)
                result[i] = long.Parse(tokens[i]);
            return result;
        }

        public void Out(object r)
        {
            if (string.IsNullOrEmpty(FileName))
                Console.WriteLine(r);
            else if (GetProd())
                File.WriteAllText(FileName, r.ToString());
            else
                Console.WriteLine(r);
        }

        private bool GetProd()
        {

            if (!prod.HasValue)
                try
                {
                    prod = Environment.MachineName != "RENADEEN-W7";
                }
                catch (Exception)
                {
                    prod = true;
                }
            return prod.Value;
        }
    }

    public static class Huj
    {
        public static T MinBy<T>(this IEnumerable<T> source, Func<T, double> func) where T : class
        {
            T result = null;
            var min = double.MaxValue;
            foreach (var item in source)
            {
                var current = func(item);
                if (min > current)
                {
                    min = current;
                    result = item;
                }
            }
            return result;
        }

        public static T MaxBy<T>(this IEnumerable<T> source, Func<T, double> func, T defaultValue = default(T))
        {
            T result = defaultValue;
            var max = double.MinValue;
            foreach (var item in source)
            {
                var current = func(item);
                if (max < current)
                {
                    max = current;
                    result = item;
                }
            }
            return result;
        }

        public static string JoinStrings(this IEnumerable<string> s, string d) { return string.Join(d, s.ToArray()); }

        public static string JoinStrings(this IEnumerable<int> s, string d) { return s.Select(x => x.ToString()).JoinStrings(d); }
        public static string JoinStrings(this IEnumerable<long> s, string d) { return s.Select(x => x.ToString()).JoinStrings(d); }
    }

}

using System;

namespace _817A
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] splitStr = Console.ReadLine().Split(' ');
            int startX = int.Parse(splitStr[0]);
            int startY = int.Parse(splitStr[1]);
            int finishX = int.Parse(splitStr[2]);
            int finishY = int.Parse(splitStr[3]);
            string[] splitStrStep = Console.ReadLine().Split(' ');
            int stepX = int.Parse(splitStrStep[0]);
            int stepY = int.Parse(splitStrStep[1]);

            if (Math.Abs(finishX - startX)%stepX != 0 || Math.Abs(finishY - startY)%stepY != 0)
            {
                Console.WriteLine("NO");
            }
            else
            {
                int countStepX = Math.Abs(finishX - startX) / stepX;
                int countStepY = Math.Abs(finishY - startY) / stepY;
                if (countStepX%2 == countStepY%2)
                {
                    Console.WriteLine("YES");
                }
                else
                {
                    Console.WriteLine("NO");
                }
            }
            Console.ReadLine();

        }
    }
}

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

namespace CF
{
	internal class Program
	{
		private static void Main(string[] args)
		{
			var sr = new InputReader(Console.In);
			//var sr = new InputReader(new StreamReader("input.txt"));
			var task = new Task();
			using (var sw = Console.Out)
			{
				//using (var sw = new StreamWriter("output.txt")) {
				task.Solve(sr, sw);
				//Console.ReadKey();
			}
		}
	}

	internal class Task
	{
		public void Solve(InputReader sr, TextWriter sw)
		{
			var input = sr.ReadArrayOfInt32();
			var x1 = input[0];
			var y1 = input[1];
			var x2 = input[2];
			var y2 = input[3];
			input = sr.ReadArrayOfInt32();
			var x = input[0];
			var y = input[1];
			var dx = Math.Abs(x2 - x1);
			var dy = Math.Abs(y2 - y1);
			var rx = dx / x;
			if (dx % x != 0)
			{
				sw.WriteLine("NO");
				return;
			}
			var ry = dy / y;
			if (dy % y != 0)
			{
				sw.WriteLine("NO");
				return;
			}
			if (rx == 0 || ry == 0)
			{
				sw.WriteLine("YES");
				return;
			}
			if (Math.Abs(rx - ry) % 2 == 0) {
				sw.WriteLine("YES");
				return;
			}

			sw.WriteLine("NO");
		}
	}
}

internal class InputReader : IDisposable
{
	private bool isDispose;
	private readonly TextReader sr;

	public InputReader(TextReader stream)
	{
		sr = stream;
	}

	public void Dispose()
	{
		Dispose(true);
		GC.SuppressFinalize(this);
	}

	public string NextString()
	{
		var result = sr.ReadLine();
		return result;
	}

	public int NextInt32()
	{
		return Int32.Parse(NextString());
	}

	public long NextInt64()
	{
		return Int64.Parse(NextString());
	}

	public string[] NextSplitStrings()
	{
		return NextString()
										.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
	}

	public T[] ReadArray<T>(Func<string, CultureInfo, T> func)
	{
		return NextSplitStrings()
										.Select(s => func(s, CultureInfo.InvariantCulture))
										.ToArray();
	}

	public int[] ReadArrayOfInt32()
	{
		return ReadArray(Int32.Parse);
	}

	public long[] ReadArrayOfInt64()
	{
		return ReadArray(Int64.Parse);
	}

	public T[] ReadArrayFromString<T>(Func<string, CultureInfo, T> func, string str)
	{
		return
										str.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
																		.Select(s => func(s, CultureInfo.InvariantCulture))
																		.ToArray();
	}

	protected void Dispose(bool dispose)
	{
		if (!isDispose)
		{
			if (dispose)
				sr.Close();
			isDispose = true;
		}
	}

	~InputReader()
	{
		Dispose(false);
	}
}

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

namespace CF
{
	internal class Program
	{
		private static void Main(string[] args)
		{
			var sr = new InputReader(Console.In);
			//var sr = new InputReader(new StreamReader("input.txt"));
			var task = new Task();
			using (var sw = Console.Out)
			{
				//using (var sw = new StreamWriter("output.txt")) {
				task.Solve(sr, sw);
				//Console.ReadKey();
			}
		}
	}

	internal class Task
	{
		public void Solve(InputReader sr, TextWriter sw)
		{
			var input = sr.ReadArrayOfInt32();
			var x1 = input[0];
			var y1 = input[1];
			var x2 = input[2];
			var y2 = input[3];
			input = sr.ReadArrayOfInt32();
			var x = input[0];
			var y = input[1];
			var dx = Math.Abs(x2 - x1);
			var dy = Math.Abs(y2 - y1);
			var rx = dx / x;
			if (dx%x != 0) {
				sw.WriteLine("NO");
				return;
			}
			var ry = dy / y;
			if (dy%y != 0) {
				sw.WriteLine("NO");
				return;
			}
			if (rx == ry || (rx == 0 || ry == 0)) {
				sw.WriteLine("YES");
				return;
			}

			sw.WriteLine("NO");
		}
	}
}

internal class InputReader : IDisposable
{
	private bool isDispose;
	private readonly TextReader sr;

	public InputReader(TextReader stream)
	{
		sr = stream;
	}

	public void Dispose()
	{
		Dispose(true);
		GC.SuppressFinalize(this);
	}

	public string NextString()
	{
		var result = sr.ReadLine();
		return result;
	}

	public int NextInt32()
	{
		return Int32.Parse(NextString());
	}

	public long NextInt64()
	{
		return Int64.Parse(NextString());
	}

	public string[] NextSplitStrings()
	{
		return NextString()
										.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
	}

	public T[] ReadArray<T>(Func<string, CultureInfo, T> func)
	{
		return NextSplitStrings()
										.Select(s => func(s, CultureInfo.InvariantCulture))
										.ToArray();
	}

	public int[] ReadArrayOfInt32()
	{
		return ReadArray(Int32.Parse);
	}

	public long[] ReadArrayOfInt64()
	{
		return ReadArray(Int64.Parse);
	}

	public T[] ReadArrayFromString<T>(Func<string, CultureInfo, T> func, string str)
	{
		return
										str.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
																		.Select(s => func(s, CultureInfo.InvariantCulture))
																		.ToArray();
	}

	protected void Dispose(bool dispose)
	{
		if (!isDispose)
		{
			if (dispose)
				sr.Close();
			isDispose = true;
		}
	}

	~InputReader()
	{
		Dispose(false);
	}
}

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

namespace ConsoleApplication1.CodeForces
{
    class _4032
    {
        private static int Next()
        {
            int c;
            int res = 0;
            do
            {
                c = reader.Read();
                if (c == -1)
                    return res;
            } while (c < '0' || c > '9');
            res = c - '0';
            while (true)
            {
                c = reader.Read();
                if (c < '0' || c > '9')
                    return res;
                res *= 10;
                res += c - '0';
            }
        }
        private static readonly StreamReader reader = new StreamReader(Console.OpenStandardInput(1024 * 10), Encoding.ASCII, false, 1024 * 10);
        private static readonly StreamWriter writer = new StreamWriter(Console.OpenStandardOutput(1024 * 10), Encoding.ASCII, 1024 * 10);

        class Node : IComparable
        {
            public long X { get; set; }
            public long Y { get; set; }
            public int CompareTo(object obj)
            {
                if (this.Y > ((Node)obj).Y)
                {
                    return 1;
                }
                if (this.Y == ((Node)obj).Y)
                {
                    return 0;
                }
                return -1;
            }
        }

        static void Main(String[] args)
        {
            var data = Console.ReadLine().TrimEnd().Split(' ').Select(double.Parse).ToList();
            var x1 = data[0];
            var y1 = data[1];
            var x2 = data[2];
            var y2 = data[3];
            data = Console.ReadLine().TrimEnd().Split(' ').Select(double.Parse).ToList();
            var x = data[0];
            var y = data[1];

            double k1 = (x2 - x1) / x;
            double k2 = (y2 - y1) / y;

            if(k1 % 1 ==0 && k2 % 1== 0 && k1%2==k2%2)
            {
                Console.WriteLine("YES");
            } else
            {
                Console.WriteLine("NO");

            }
        }

    }
}

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

namespace HayCragrer
{
    class Problem4
    {
        static void Main(string[] args)
        {
            int[] coords = new int[4];
            string[] text = Console.ReadLine().Split();
            string[] text1 = Console.ReadLine().Split();
            int[] steps = new int[2];
            for (int i = 0; i < 4; i++)
            {
                coords[i] = int.Parse(text[i]);
            }
            for (int i = 0; i < 2; i++)
            {
                steps[i] = int.Parse(text1[i]);
            }
            int x = coords[2] - coords[0];
            int y = coords[3] - coords[1];
            if ((x % steps[0] == 0) && (y % steps[1] == 0))
            {
                if ((x / steps[0] -y / steps[1]) % 2==0)
                {
                    Console.WriteLine("YES");
                }

            }
            else
            {
                Console.WriteLine("NO");
            }
        }
    }
}

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

namespace HayCragrer
{
    class Problem4
    {
        static void Main(string[] args)
        {
            int [] coords = new int [4];
            string[] text = Console.ReadLine().Split();
            string[] text1 = Console.ReadLine().Split();
            int[] steps = new int[2];
            for (int i = 0; i < 4; i++)
            {
                coords[i] = int.Parse(text[i]);
            }
            for (int i = 0; i < 2; i++)
            {
                steps[i] = int.Parse(text1[i]);
            }
            if (((coords[2]-coords[0])%steps[0]==0) && ((coords[3] - coords[1])%steps[1] == 0))
            {
                if (coords[2] / steps[0] % 2 == coords[3] / steps[1] % 2)
                {
                    Console.WriteLine("YES");
                }
            }
            else
            {
                Console.WriteLine("NO");
            }
        }
    }
}

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

namespace Achill
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> cord = Console.ReadLine().Split().Select(item=>int.Parse(item)).ToList();
            List<int> step = Console.ReadLine().Split().Select(item=>int.Parse(item)).ToList();
            Func<double, double> LeftO = y1 => (y1 - cord[1]) / step[1];
            double y = 0.5 * step[1] * ((cord[2] - cord[0])/step[0] + (cord[1]  + cord[3]) / step[1]);
            double x = LeftO(y) * step[0] + cord[0];
            bool res = Math.Truncate(x) == x && Math.Truncate(y) == y;
            if (res)
            {
                res = (Math.Abs(x-cord[0])%step[0] == 0) && (Math.Abs(y - cord[1]) % step[1] == 0);
                res = res && (Math.Abs(x - cord[2]) % step[0] == 0) && (Math.Abs(y - cord[3]) % step[1] == 0);
            }
            Console.WriteLine(res ? "YES" : "NO");
        }
    }
}

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

namespace CodeForces
{
    class A
    {
        static void Main(string[] args)
        {
            string[] token = Console.ReadLine().Split();
            int x1 =int.Parse(token[0]);
            int y1 = int.Parse(token[1]);
            int x2 = int.Parse(token[2]);
            int y2 = int.Parse(token[3]);

            string[] token2 = Console.ReadLine().Split();
            int x = int.Parse(token2[0]);
            int y = int.Parse(token2[1]);
            string s = "YES";
            if(x==x1||x==x2||y==y1||y==y2)
            {
               s = "NO";
            }
            Console.WriteLine(s);

        }

    }
}

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

namespace CodeForces
{
    class A
    {
        static void Main(string[] args)
        {
            string[] token = Console.ReadLine().Split();
            int x1 =int.Parse(token[0]);
            int y1 = int.Parse(token[1]);
            int x2 = int.Parse(token[2]);
            int y2 = int.Parse(token[3]);

            string[] token2 = Console.ReadLine().Split();
            int x = int.Parse(token2[0]);
            int y = int.Parse(token2[1]);

            if((x1-x2)%x==0&&(y1-y2)%y==0&&((x1-x2)/x)%2==((y1-y2)/y)%2)
            {
               Console.WriteLine("YES");
            }else{
               Console.WriteLine("NO");
            }
        }

    }
}

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

namespace CodeForces
{
    class A
    {
        static void Main(string[] args)
        {
            string[] token = Console.ReadLine().Split();
            int x1 =int.Parse(token[0]);
            int y1 = int.Parse(token[1]);
            int x2 = int.Parse(token[2]);
            int y2 = int.Parse(token[3]);

            string[] token2 = Console.ReadLine().Split();
            int x = int.Parse(token2[0]);
            int y = int.Parse(token2[1]);
            string s = "YES";

            int X1 = x - x1;
            int Y1 = y - y1;
            int X2 = x2 - x;
            int Y2 = y2 - y;

            if(X1==0||X2==0||Y2==0||Y1==0)
            {
               s = "NO";
            }

            Console.WriteLine(s);

        }

    }
}

#region Using Statements
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

#endregion
namespace csConsoleforStudy
{
 using System.Collections.Generic;
 using System.Globalization;

 public class Printer : StreamWriter
 {
  public override IFormatProvider FormatProvider
  {
   get
   {
    return CultureInfo.InvariantCulture;
   }
  }

  public Printer(Stream stream): base (stream, new UTF8Encoding(false, true))
  {
  }

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

 class Program
 {
  static readonly Encoding TargetEcoding = Encoding.Unicode;
  static void Main(string[] args)
  {
   OpenStream();
   Solver s = new Solver();
   s.Solve();
   CloseStream();
  }

  static void OpenStream()
  {
  }

  static void CloseStream()
  {
  }

  static void CheckMemory()
  {
  }
 }

 class Solver
 {
  public static readonly Encoding TargetEncoding = Encoding.Unicode;
  const int SIZE = 5005;
  private const double AbsoluteError = 1e-10;
  private const double RelativeError = 1e-8;
  static int mod = 1000000007;
  public void Solve()
  {
   var in1 = ria();
   int fx = in1[0];
   int fy = in1[1];
   int tx = in1[2];
   int ty = in1[3];
   int targetx = tx - fx + 1000000;
   int targety = ty - fy + 1000000;
   var in2 = ria();
   int a = 0;
   int b = 0;
   while (targetx > 0)
   {
    targetx -= in2[0];
    a++;
   }

   while (targety > 0)
   {
    targety -= in2[1];
    b++;
   }

   if ((a + b) % 2 == 0)
    Console.WriteLine("YES");
   else
    Console.WriteLine("NO");
  }

#region SolverUtils
  private static List<int> factorial = new List<int>(new int[]{1});
  private static int NextInt()
  {
   int c;
   int res = 0;
   do
   {
    c = Console.Read();
    if (c == -1)
     return res;
   }
   while (c < '0' || c > '9');
   res = c - '0';
   while (true)
   {
    c = Console.Read();
    if (c < '0' || c > '9')
     return res;
    res *= 10;
    res += c - '0';
   }
  }

  static string rs()
  {
   return Console.ReadLine();
  }

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

  static uint rui()
  {
   return uint.Parse(Console.ReadLine());
  }

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

  static ulong rul()
  {
   return ulong.Parse(Console.ReadLine());
  }

  static double rd()
  {
   return double.Parse(Console.ReadLine(), CultureInfo.InvariantCulture);
  }

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

  static int[] ria()
  {
   return Array.ConvertAll(Console.ReadLine().Trim(' ').Split(' '), e => int.Parse(e));
  }

  static uint[] ruia()
  {
   return Array.ConvertAll(Console.ReadLine().Trim(' ').Split(' '), e => uint.Parse(e));
  }

  static long[] rla()
  {
   return Array.ConvertAll(Console.ReadLine().Trim(' ').Split(' '), e => long.Parse(e));
  }

  static ulong[] rula()
  {
   return Array.ConvertAll(Console.ReadLine().Trim(' ').Split(' '), e => ulong.Parse(e));
  }

  static double[] rda()
  {
   return Array.ConvertAll(Console.ReadLine().Trim(' ').Split(' '), e => double.Parse(e));
  }

  static void ReadLineAndAssign(string type, params object[] p)
  {
   dynamic input;
   if (type.StartsWith("i"))
    input = ria();
   else if (type.StartsWith("l"))
    input = rla();
   else if (type.StartsWith("d"))
    input = rda();
   else
    throw new ArgumentException("no match " + type.ToString());
   for (int i = 0; i < p.Length; i++)
   {
    p[i] = input[i];
   }
  }

  static void SwapIfGreater<T>(ref T lhs, ref T rhs)where T : IComparable<T>
  {
   T temp;
   if (lhs.CompareTo(rhs) > 0)
   {
    temp = lhs;
    lhs = rhs;
    rhs = temp;
   }
  }

  static bool DoubleEqual(double a, double b)
  {
   double diff = Math.Abs(a - b);
   if (diff < AbsoluteError)
    return true;
   return diff <= RelativeError * Math.Max(Math.Abs(a), Math.Abs(b));
  }

  static dynamic abs(dynamic num)
  {
   return Math.Abs(num);
  }

  static dynamic max(dynamic a, dynamic b)
  {
   return Math.Max(a, b);
  }

  static void For(int start, int end, Action method)
  {
   for (int i = start; i < end; i++)
   {
    method.Invoke();
   }
  }

  static void For(int start, int end, Action<int> method, int i)
  {
   for (i = start; i < end; i++)
   {
    method.DynamicInvoke(i);
   }
  }

  static int C(int n, int k)
  {
   return P(n, k) / Factorial(k);
  }

  static int P(int n, int r)
  {
   return Factorial(n) / Factorial(n - r);
  }

  static int Factorial(int n)
  {
   if (factorial.Count <= n)
    factorial.Add(Factorial(n - 1) * n);
   return factorial[n];
  }

  static bool IsEven(int a)
  {
   return (a % 2) == 0;
  }

  static bool IsOdd(int a)
  {
   return !IsEven(a);
  }

  static int powmod(int a, int b)
  {
   if (b == 0)
    return 1;
   if (b == 1)
    return a;
   int i = powmod(a, b / 2);
   i *= i;
   i %= mod;
   if (b % 2 == 0)
    return i;
   else
    return ((i * a) % mod);
  }
#endregion
 }
#region SolverUtils
#endregion
#region Data Structure
#endregion
#region Algorithm
#endregion
#region Library Method/Fields
#region Members for Internal Support
#endregion Members for Internal Support
#region Public Properties
#endregion Public Properties
#region Public Instance Methods
#endregion Public Instance Methods
#region Constructors
#endregion Constructors
#region Public Static Methods
#endregion Public Static Methods
#region Operator Overloads
#endregion Operator Overloads
#region explicit conversions from BigRational
#endregion explicit conversions from BigRational
#region implicit conversions to BigRational
#endregion implicit conversions to BigRational
#region serialization
#endregion serialization
#region instance helper methods
#endregion instance helper methods
#region static helper methods
#endregion static helper methods
#region Exceptions
#endregion
#endregion
}
#region Libraries
#region operation methods
#endregion
#region Operators
#endregion
#region DataStructures
#region IComparable implementation
#endregion
#region Model
#endregion
#region Constructors
#endregion
#region Internal
#region IEqualityComparer implementation
#endregion
#endregion
#region IGraph implementation
#endregion
#region Clique invariants
#endregion
#region Clique methods
#endregion
#region IEquatable implementation
#endregion
#endregion
#region Algorithms
#endregion
#endregion

using System;

namespace _817A
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] splitStr = Console.ReadLine().Split(' ');
            int startX = int.Parse(splitStr[0]);
            int startY = int.Parse(splitStr[1]);
            int finishX = int.Parse(splitStr[2]);
            int finishY = int.Parse(splitStr[2]);
            string[] splitStrStep = Console.ReadLine().Split(' ');
            int stepX = int.Parse(splitStrStep[0]);
            int stepY = int.Parse(splitStrStep[1]);

            if (Math.Abs(finishX - startX)%stepX != 0 || Math.Abs(finishY - startY)%stepY != 0)
            {
                Console.WriteLine("NO");
            }
            else
            {
                int countStepX = Math.Abs(finishX - startX) / stepX;
                int countStepY = Math.Abs(finishY - startY) / stepY;
                if (countStepX%2 == countStepY%2)
                {
                    Console.WriteLine("YES");
                }
                else
                {
                    Console.WriteLine("NO");
                }
            }
            Console.ReadLine();

        }
    }
}