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.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.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.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.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.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();

        }
    }
}