import java.util.*;

/**
 * Calculate the size of the square that we should be filling then walk
 * along the perimeter of this square. For each order of rectangles and
 * for each possible orientation, place each rectangle along the perimeter
 * at the first available position. After placing each rectangle make
 * sure that it does not exceed the bounds of the square nor intersect
 * an already placed rectangle.
 *
 * @author Finn Lidbetter
 */

public class foursq_finn {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        int[] lengths = new int[4];
        int[] widths = new int[4];
        int area = 0;
        for (int i=0; i<4; i++) {
            lengths[i] = sc.nextInt();
            widths[i] = sc.nextInt();
            area += lengths[i]*widths[i];
        }
        int side = (int)Math.sqrt(area);
        if (side*side!=area) {
            System.out.println(0);
            return;
        }
        for (int i=0; i<4; i++) {
            if (lengths[i]>side || widths[i]>side) {
                System.out.println(0);
                return;
            }
        }
        int[][] permutations = {
            {0,1,2,3},
            {0,1,3,2},
            {0,2,1,3},
            {0,2,3,1},
            {0,3,1,2},
            {0,3,2,1},
            {1,0,2,3},
            {1,0,3,2},
            {1,2,0,3},
            {1,2,3,0},
            {1,3,0,2},
            {1,3,2,0},
            {2,0,1,3},
            {2,0,3,1},
            {2,1,0,3},
            {2,1,3,0},
            {2,3,0,1},
            {2,3,1,0},
            {3,0,1,2},
            {3,0,2,1},
            {3,1,0,2},
            {3,1,2,0},
            {3,2,0,1},
            {3,2,1,0}
        };
        for (int permutationIndex=0; permutationIndex<permutations.length; permutationIndex++) {
            int[] permutation = permutations[permutationIndex];
            for (int rotation=0; rotation<(1<<4); rotation++) {
                Rectangle[] rects = new Rectangle[4];
                boolean valid = true;
                for (int i=0; i<4; i++) {
                    Interval firstUncovered = computeFirstUncovered(rects, side);
                    int w = widths[permutation[i]];
                    int l = lengths[permutation[i]];
                    if ((rotation&(1<<i))>0) {
                        int tmp = w;
                        w = l;
                        l = tmp;
                    }
                    Rectangle r;
                    if (firstUncovered.lo<side) {
                        r = new Rectangle(firstUncovered.lo, 0, firstUncovered.lo + w, l);
                    } else if (firstUncovered.lo<2*side) {
                        r = new Rectangle(side - w, firstUncovered.lo - side, side, firstUncovered.lo - side + l);
                    } else if (firstUncovered.lo<3*side) {
                        r = new Rectangle(side - (firstUncovered.lo - (2*side)) - w, side - l, side - (firstUncovered.lo - (2*side)), side);
                    } else {
                        r = new Rectangle(0, side - (firstUncovered.lo - (3*side)) - l, w, side - (firstUncovered.lo - (3*side)));
                    }
                    if (r.x1<0 || r.y1<0 || r.x2>side || r.y2>side) {
                        valid = false;
                        break;
                    }
                    for (int j=0; j<i; j++) {
                        if (r.intersectsNonTrivially(rects[j])) {
                            valid = false;
                            break;
                        }
                    }
                    if (!valid) {
                        break;
                    }
                    rects[i] = r;
                }
                if (valid) {
                    System.out.println(1);
                    return;
                }
            }
        }
        System.out.println(0);
        return;
    }
    static Interval computeFirstUncovered(Rectangle[] rectangles, int side) {
        ArrayList<Interval> covered = new ArrayList<>();
        for (Rectangle r: rectangles) {
            if (r==null) {
                break;
            }
            int x1 = r.x1;
            int y1 = r.y1;
            int x2 = r.x2;
            int y2 = r.y2;
            if (x1==0) {
                covered.add(new Interval(4*side - y2 ,4*side - y1));
            }
            if (y1==0) {
                covered.add(new Interval(x1, x2));
            }
            if (x2==side) {
                covered.add(new Interval(side + y1, side + y2));
            }
            if (y2==side) {
                covered.add(new Interval(3*side - x2, 3*side - x1));
            }
        }
        Collections.sort(covered);
        if (covered.size()==0) {
            return new Interval(0, 4*side);
        }
        if (covered.size()==1) {
            if (covered.get(0).lo!=0) {
                return new Interval(0, covered.get(0).lo);
            }
        }
        for (int i=1; i<covered.size(); i++) {
            if (covered.get(i-1).hi != covered.get(i).lo) {
                return new Interval(covered.get(i-1).hi, covered.get(i).lo);
            }
        }
        return new Interval(covered.get(covered.size()-1).hi, 4*side);
    }
}
class Rectangle {
    int x1,y1,x2,y2;
    public Rectangle(int xx1, int yy1, int xx2, int yy2) {
        x1 = xx1;
        y1 = yy1;
        x2 = xx2;
        y2 = yy2;
        if (x2<x1) {
            int tmp = x1;
            x1 = x2;
            x2 = tmp;
        }
        if (y2<y1) {
            int tmp = y1;
            y1 = y2;
            y2 = tmp;
        }
    }
    public boolean intersectsNonTrivially(Rectangle r2) {
        if (x2<=r2.x1 || x1>=r2.x2 || y2<=r2.y1 || y1>=r2.y2) {
            return false;
        }
        return true;
    }
    public String toString() {
        return String.format("[(%d,%d),(%d,%d)]",x1,y1,x2,y2);
    }
}
class Interval implements Comparable<Interval>{
    int lo,hi;
    public Interval(int llo, int hhi) {
        lo = llo;
        hi = hhi;
    }
    public int compareTo(Interval i2) {
        if (lo==i2.lo) {
            return hi - i2.hi;
        }
        return lo - i2.lo;
    }
    public String toString() {
        return String.format("[%d,%d]",lo,hi);
    }
}