#include <bits/stdc++.h>
#include <bits/extc++.h> 
using namespace std;
#define sz(x) (int)(x).size()
#define rep(i, l, r) for (int i = l; i < (r); i++)
#define all(x) begin(x), end(x)

using ll = long long;
using vi = vector<int>;

const ll INF = numeric_limits<ll>::max() / 100;

struct MCMF{

	struct edge {
		int from, to, rev;
		ll cap, cost, flow;
	};

	int N;
	vector<vector<edge>> ed;
	vi seen;
	vector<ll> dist, pi;
	vector<edge*> par;

	MCMF(int N) : N(N), ed(N), seen(N), dist(N), pi(N), par(N) {}

	void addEdge(int from, int to, ll cap, ll cost) {
		if (from == to) return;
		ed[from].push_back(edge{ from, to, sz(ed[to]), cap, cost, 0});
		ed[to].push_back(edge{to, from, sz(ed[from])-1, 0, -cost, 0});
	}

	void path(int s) {
		fill(all(seen), 0);
		fill(all(dist), INF);
		dist[s] = 0; ll di;

		__gnu_pbds::priority_queue<pair<ll, int>> q;
		vector<decltype(q)::point_iterator> its(N);
		q.push({0, s});
		while (!q.empty()) {
			s = q.top().second; q.pop();
			seen[s] = 1; di = dist[s] + pi[s];
			for (edge& e : ed[s]) if (!seen[e.to]) {
				ll val = di - pi[e.to] + e.cost;
				if (e.cap - e.flow > 0 && val < dist[e.to]) {
					dist[e.to] = val;
					par[e.to] = &e;
					if (its[e.to] == q.end()) {
						its[e.to] = q.push({-dist[e.to], e.to});
					}
					else {
						q.modify(its[e.to], {-dist[e.to], e.to});
					}
				}
			}
		}

		rep(i,0,N) pi[i] = min(pi[i] + dist[i], INF);
	}

	pair<ll, ll> maxflow(int s, int t) {
		ll totflow = 0, totcost = 0;
		while (path(s), seen[t]) {
			ll fl = INF;
			for (edge* x = par[t]; x; x = par[x->from]) {
				fl = min(fl, x->cap - x->flow);
			}

			totflow += fl;
			for(edge* x = par[t]; x; x = par[x->from]) {
				x->flow += fl;
				ed[x->to][x->rev].flow -= fl;
			}
		}

		rep(i, 0, N)for(edge& e : ed[i]) totcost += e.cost * e.flow;
		return {totflow, totcost/2};
	}
};

bool is_prime(ll x) {
    for (ll a = 2; a * a <= x; a++) {
        if (x % a == 0)return 0;
    }
    return 1;
}

const unsigned long long  inf = 1e18 + 2;
unsigned long long  safe_pow(unsigned long long  x, int e) {
    unsigned long long  a = 1;
    rep(_, 0, e) {
        if (a > inf / x)return -1;
        a *= x;
    }
    return a;
}

using pii = pair<int, int>;

int main() {
    int n = 4;

    vector<pii> p(n);
    rep(i, 0, n)cin >> p[i].first >> p[i].second;
    int s = 0;
    rep(i, 0, 4)s += p[i].first * p[i].second;
    int m = -1;
    rep(i, 1, 10000) {
        if (i * i == s) {
            m = i;
        }
    }
    if (m == -1) {
        cout << 0 << endl;
        return 0;
    }

    vector<vector<bool>> used(m, vector<bool>(m));
    int bit = 0;
    auto find = [&]->pii{
        rep(i, 0, m)rep(j, 0, m)if(!used[i][j])return {i, j};
    };

    auto check = [&](int x, int y, int h, int w)->bool {
        rep(i, x, x+h)rep(j, y, y+w)if(i >= m || j >= m || used[i][j])return 0;
        return 1;
    };

    auto flip = [&](int x, int y, int h, int w)->void {
        rep(i, x, x+h)rep(j, y, y+w)used[i][j]=!used[i][j];
    };

    vi idx(4);iota(all(idx), 0);
    bool flag = 0;
    auto dfs = [&](auto self)->void {
        if (flag)return;
        if (bit == (1<<n) - 1) {flag = 1;return;}
        // cout << bit << endl;
        rep(i, 0, n) {
            if (bit >> i & 1)continue;
            auto [x, y] = find();
            bit ^= (1 << i);
            if (check(x, y, p[i].first, p[i].second)) {
                flip(x, y, p[i].first, p[i].second);
                self(self);
                flip(x, y, p[i].first, p[i].second);
            }
            swap(p[i].first, p[i].second);
            if (check(x, y, p[i].first, p[i].second)) {
                flip(x, y, p[i].first, p[i].second);
                self(self);
                flip(x, y, p[i].first, p[i].second);
            }
            swap(p[i].first, p[i].second);
            bit ^= (1 << i);
        }
        
    };

    dfs(dfs);
    cout << flag << endl;
 
}