// classfrac.cpp: определяет точку входа для консольного приложения.
//

#include "stdafx.h"
#include <iostream>
#include <cmath>
#include <cstdlib>
#include <cstdio>

using namespace std;

class zFrac {
public:
    zFrac() : num(0), denom(1) {};
    explicit zFrac(const int aNum) : num(aNum), denom(1) {};
    zFrac(const int aNum, const int aDenom) : num(aNum), denom(aDenom) { norm(); };

    void norm() {
        int numTemp = abs(num), denomTemp = abs(denom);
        while (numTemp * denomTemp) {
            if (numTemp > denomTemp) numTemp %= denomTemp;
            else denomTemp %= numTemp;
        }
        num /= (numTemp + denomTemp);
        denom /= (numTemp + denomTemp);
    }


    zFrac& operator += (zFrac const &r) {
        num = num * r.denom + r.num * denom;
        denom *= r.denom;
        this->norm();
        return *this;
    }

    zFrac& operator += (int a) {
        zFrac temp(a);
        *this += temp;
        return *this;
    }

    zFrac operator + (zFrac const &r) const {
        zFrac temp(*this);
        temp += r;
        return temp;
    }

    zFrac& operator -= (zFrac const &r) {
        num = num * r.denom - denom * r.num;
        denom = denom * r.denom;
        this->norm();
        return *this;
    }

    zFrac& operator -= (int a) {
        zFrac temp(a);
        *this -= temp;
        return *this;
    }

    zFrac operator - (zFrac const &r) const {
        zFrac temp = *this;
        temp -= r;
        return temp;
    }

    zFrac& operator *= (zFrac const &r) {
        num *= r.num;
        denom *= r.denom;
        this->norm();
        return *this;
    }

    zFrac& operator *= (int const &a) {
        this->num *= a;
        this->norm();
        return *this;
    }

    zFrac operator * (zFrac const &r) const {
        zFrac temp(*this);
        temp *= r;
        return temp;
    }


    zFrac& operator /= (zFrac const &r) {
        (*this).num *= r.denom;
        (*this).denom *= r.num;
        this->norm();
        return *this;
    }

    zFrac& operator /= (int a) {
        this->denom *= a;
        this->norm();
        return *this;
    }

    zFrac operator / (zFrac const &r) const {
        zFrac temp = *this;
        temp /= r;
        return temp;
    }

    friend zFrac operator / (int const &a, zFrac const &r) {
        zFrac temp1(r);
        temp1.denom *= a;
        temp1.norm();
        return temp1;
    }

    friend zFrac operator / (zFrac const &r, int const &a) {
        zFrac temp1(r);
        temp1.denom *= a;
        temp1.norm();
        return temp1;
    }

     zFrac& operator = (int a) {
        num = a, denom = 1;
        return *this;
    }

    bool operator < (zFrac const &r) const {
        return num * r.denom < r.num * denom;
    }

    bool operator <= (zFrac const &r) const {
        return num * r.denom <= r.num * denom;
    }

    bool operator > (zFrac const &r) const {
        return num * r.denom > r.num * denom;
    }

    bool operator >= (zFrac const &r) const {
        return num * r.denom >= r.num * denom;
    }

    bool operator == (zFrac const &r)const {
        return num == r.num && denom == r.denom;
    }

    bool operator != (zFrac const &r) const {
        return !(r == *this);
    }

    explicit operator double() {
        return (double)num / denom;
    }
    //proxy класс

    friend ostream& operator << (ostream& os, zFrac const &r) {
        if (r.denom != 1) os << r.num << "\\" << r.denom;
        else os << r.num;
        return os;
    }

    friend istream& operator >> (istream& is, zFrac &r) {
        char ch;
        is >> r.num;
        auto fl = is.flags();
        is.unsetf(ios_base::skipws);
        is >> ch;
        if (ch == '/' || ch == '\\')
            is >> r.denom;
        else {
            is.putback(ch);
            r.denom = 1;
        }
        zFrac f;
        is.setf(ios_base::skipws);
        r.norm();
        return is;
    }

    int Num() const { return num; }
    int Denom() const { return denom; }

private:
    int num;
    int denom;
};

zFrac operator + (int const &a, zFrac const &r) {
    zFrac temp1(a);
    temp1 += r;
    return temp1;
}

zFrac operator + (zFrac const &r, int const &a) {
    zFrac temp1(a);
    temp1 += r;
    return temp1;
}

zFrac operator - (int const &a, zFrac const &r) {
    zFrac temp1(a);
    temp1 -= r;
    return temp1;
}

zFrac operator - (zFrac const &r, int const &a) {
    zFrac temp1(a);
    temp1 -= r;
    return temp1;
}

zFrac operator * (zFrac const &r, int const &a) {
    zFrac temp1(a);
    temp1 *= r;
    return temp1;
}

zFrac operator * (int const &a, zFrac const &r) {
    zFrac temp1(a);
    temp1 *= r;
    return temp1;
}

double const eps = 0.0000000001;

bool operator > (int const &a, zFrac r) {
    return (double)a > (double)r;
}

bool operator > (zFrac r, int const &a) {
    return (double)r > (double)a;
}

bool operator >= (int const &a, zFrac r) {
    return (double)a > (double)r || abs((double)r - (double)a) < eps;
}

bool operator >= (zFrac r, int const &a) {
    return (double)r > (double)a || abs((double)r - (double)a) < eps;
}

bool operator < (int const &a, zFrac r) {
    return (double)a < (double)r;
}

bool operator < (zFrac r, int const &a) {
    return (double)r < (double)a;
}

bool operator <= (int const &a, zFrac r) {
    return (double)a < (double)r || abs((double)r - (double)a) < eps;
}

bool operator <= (zFrac r, int const &a) {
    return (double)r < (double)a || abs((double)r - (double)a) < eps;
}

bool operator == (int const &a, zFrac r) {
    return abs((double)r - (double)a) < eps;
}

bool operator == (zFrac r, int const &a) {
    return abs((double)r - (double)a) < eps;
}

bool operator != (int const &a, zFrac r) {
    return !(r == a);
}

bool operator != (zFrac r, int const &a) {
    return !(r == a);
}

int main()
{
    zFrac r1(1, 2), r2(1, 3);

    r1 = r2;
    while (true) {
        zFrac a, b, c, d;
        cin >> b >> c;
        const int v = 1;
        cin >> a >> d;
        cout << (a < v) << (v < d) << (a <= v) << "\n";

    }

    return 0;
}