#include<bits/stdc++.h>
namespace {
#pragma GCC diagnostic ignored "-Wunused-function"
#include<atcoder/all>
#pragma GCC diagnostic warning "-Wunused-function"
using namespace std;
using namespace atcoder;
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define rrep(i,n) for(int i = (int)(n) - 1; i >= 0; i--)
#define all(x) begin(x), end(x)
#define rall(x) rbegin(x), rend(x)
template<class T> bool chmax(T& a, const T& b) { if (a < b) { a = b; return true; } else return false; }
template<class T> bool chmin(T& a, const T& b) { if (b < a) { a = b; return true; } else return false; }
using ll = long long;
using P = pair<int,int>;
using VI = vector<int>;
using VVI = vector<VI>;
using VL = vector<ll>;
using VVL = vector<VL>;
using mint = modint1000000007;



template<class T, int N>
struct Mat: std::array<std::array<T, N>, N> {
    friend Mat<T, N> operator*(const Mat& A, const Mat& B) {
        Mat<T, N> C = {};
        for(int i = 0; i < N; i++) {
            for(int k = 0; k < N; k++) {
                for(int j = 0; j < N; j++) {
                    C[i][j] += A[i][k] * B[k][j];
                }
            }
        }
        return C;
    }
    friend std::array<T, N> operator*(const Mat& A, const std::array<T, N>& v) {
        std::array<T, N> x = {};
        for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) x[i] += A[i][j] * v[j];
        return x;
    }
    friend Mat<T, N> operator+(const Mat& A, const Mat& B) {
        Mat<T, N> C;
        for(int i = 0; i < N; i++) {
            for(int j = 0; j < N; j++) {
                C[i][j] = A[i][j] + B[i][j];
            }
        }
        return C;
    }
    Mat<T, N>& operator*=(const Mat& A) { return *this = *this * A; }
    Mat<T, N>& operator+=(const Mat& A) {
        for(int i = 0; i < N; i++) {
            for(int j = 0; j < N; j++) {
                (*this)[i][j] += A[i][j];
            }
        }
    }
    static Mat<T, N> I() {
        Mat<T, N> X = {};
        for(int i = 0; i < N; i++) X[i][i] = 1;
        return X;
    }
    Mat<T, N> pow(long long k) const {
        assert(k >= 0);
        auto X = *this;
        auto Y = I();
        while(k) {
            if (k & 1) Y *= X;
            k >>= 1;
            if (k) X *= X;
        }
        return Y;
    }
    Mat<T, N> inv() const {
        auto X = *this;
        auto Y = I();
        for(int p = 0; p < N; p++) {
            bool ok = false;
            for(int i = p; i < N; i++) {
                if (X[i][p] != T()) {
                    ok = true;
                    if (i != p) {
                        // std::swap(X[i], X[p]);
                        for(int j = p; j < N; j++) std::swap(X[i][j], X[p][j]);
                        std::swap(Y[i], Y[p]);
                    }
                    break;
                }
            }
            assert(ok);
            T c = 1 / X[p][p];
            for(int j = p; j < N; j++) X[p][j] *= c;
            for(int j = 0; j < N; j++) Y[p][j] *= c;
            for(int i = 0; i < N; i++) if (i != p) {
                T c = X[i][p];
                for(int j = p; j < N; j++) X[i][j] -= c * X[p][j];
                for(int j = 0; j < N; j++) Y[i][j] -= c * Y[p][j];
            }
        }
        return Y;
    }

    void elim() {
        auto& X = *this;
        int i_next = 0;
        for(int p = 0; p < N; p++) {
            bool found = false;
            for(int i = i_next; i < N; i++) {
                if (X[i][p] != T()) {
                    found = true;
                    if (i != i_next) swap(X[i], X[i_next]);
                    break;
                }
            }
            if (!found) continue;
            auto mul = X[i_next][p].inv();
            for (int j = p; j < N; j++) X[i_next][j] *= mul;
            for(int i = i_next + 1; i < N; i++) {
                T mul = X[i][p];
                for (int j = p; j < N; j++) X[i][j] -= X[i_next][j] * mul;
            }
            i_next++;
        }
        return;
    }
    friend std::ostream& operator<<(std::ostream& os, const Mat<T, N>& A) {
        for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) os << A[i][j] << " \n"[j + 1 == N];
        return os;
    }
};


std::default_random_engine gen(std::chrono::system_clock::now().time_since_epoch().count());
using dist_type = std::uniform_int_distribution<>;
using param_type = dist_type::param_type;

int RI(int L, int R) { assert(L < R); return dist_type(L, R - 1)(gen); }

} int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  int a[2][2], b[2][2];
  rep(i, 2) rep(j, 2) cin >> a[i][j];
  rep(i, 2) rep(j, 2) cin >> b[i][j];
  Mat<mint, 4> m;
  m[0] = {a[0][0] - b[0][0], a[1][0], -b[0][1], 0};
  m[1] = {a[0][1], a[1][0] - b[0][0], 0, -b[0][1]};
  m[2] = {-b[1][0], 0, a[0][0] - b[1][1], a[1][0]};
  m[3] = {0, -b[1][0], a[0][1], a[1][1] - b[1][1]};
  m.elim();
  if (m[3][3] != 0) {
    cout << "No\n";
    return 0;
  }
  bool ok = false;
  rep(_, 10) {
    int rank = 4;
    while (rank && m[rank-1] == array<mint, 4>{}) rank--;
    int r = 3;
    mint v[4];
    rrep(i, rank) {
      int j = 0;
      while (m[i][j] == 0) j++;
      while (r > j) v[r--] = RI(0, mint::mod());
      for (int jj = j + 1; jj < 4; jj++) v[r] -= m[i][jj] * v[jj];
      r--;
    }
    while (r >= 0) v[r--] = RI(0, mint::mod());
    // rep(i, 4) cout << v[i].val() << " \n"[i + 1 == 4];
    if (v[0] * v[3] != v[1] * v[2]) {
      ok = true;
      break;
    }
  }
  cout << (ok ? "Yes\n" : "No\n");
}