#include <array>
#include <functional>
#include <iostream>
#include <vector>

using namespace std;

template<class Fun>
class y_combinator_result {
  Fun fun_;
public:
  template<class T>
  explicit y_combinator_result(T &&fun): fun_(std::forward<T>(fun)) {}

  template<class ...Args>
  decltype(auto) operator()(Args &&...args) {
    return fun_(std::ref(*this), std::forward<Args>(args)...);
  }
};

template<class Fun>
decltype(auto) y_combinator(Fun &&fun) {
  return y_combinator_result<std::decay_t<Fun>>(std::forward<Fun>(fun));
}

int main() {
  vector<vector<bool>> dp;
  vector<array<int, 2>> v(4);
  vector<bool> used(4);
  int side = 1;
  auto dfs = y_combinator([&](auto self, int curr) -> bool {
    if(curr == 4) return true;
    int idx = 0;
    while(dp[idx/side][idx%side]) idx++;
    int sx = idx / side;
    int sy = idx % side;
    for(int i = 0; i < 4; i++) {
      if(used[i]) continue;
      used[i] = true;
      for(int a = 0; a < 2; a++) {
        if(sx + v[i][0] <= side && sy + v[i][1] <= side) {
          bool can = true;
          for(int k = 0; k < v[i][0]; k++) for(int l = 0; l < v[i][1]; l++) can = can && !dp[sx + k][sy + l];
          if(can) {
            for(int k = 0; k < v[i][0]; k++) for(int l = 0; l < v[i][1]; l++) dp[sx + k][sy + l] = true;
            if(self(curr+1)) return true;
            for(int k = 0; k < v[i][0]; k++) for(int l = 0; l < v[i][1]; l++) dp[sx + k][sy + l] = false;
          }
        }
        swap(v[i][0], v[i][1]);
      }
      used[i] = false;
    }
    return false;
  });
  int area = 0;
  for(auto& x: v) {
    cin >> x[0] >> x[1];
    area += x[0] * x[1];
  }
  while(side * side < area) side++;
  if(side * side != area) {
    cout << "0\n";
    return 0;
  }
  dp.resize(side);
  for(auto& x: dp) x.resize(side);
  cout << dfs(0) << "\n";
}