import re
import math


class SolveTask:
    def __init__(self):
        self._f = math.factorial

    def solve(*args, **kwargs):
        raise NotImplementedError

    def combinations(self, n, k):
        return self._f(n) // self._f(k) // self._f(n - k)

class Solve4(SolveTask):
    def solve(self, f1, f2, f3):
        """Пока можем ответить только о том, что принадлежит классу Поста
        """

        method_check = ['is_t0', 'is_t1', 'is_linear', 'is_monotone', 'is_supplement']
        flags = [1, 1, 1, 1, 1]

        for i, method in enumerate(method_check):
            flags[i] *= getattr(self, method)(f1)
            flags[i] *= getattr(self, method)(f2)
            flags[i] *= getattr(self, method)(f3)

        return sum(flags) == 0

    def is_t0(self, f):
        return f[0] == '0'

    def is_t1(self, f):
        return f[-1] == '1'

    def is_supplement(self, f):
        for i in range(len(f) // 2):
            if f[i] == f[-1-i]:
                return False

        return True

    def is_linear(self, f):
        a = [f]

        for j in range(1, len(f)):
            new_a = ''

            for i in range(len(a[-1])-1):
                if a[-1][i] == a[-1][i+1]:
                    new_a += '0'
                else:
                    new_a += '1'

            a.append(new_a)

        for i in [3, 5, 6, 7]:
            if a[i][0] == '1':
                return False

        return True

    def is_monotone(self, f):
        get_bin = lambda x: '0' * (3 - len(bin(x)[2:])) + bin(x)[2:]

        for i in range(len(f)):
            for j in range(i, len(f)):
                if self.is_large(get_bin(i), get_bin(j)) and f[i] < f[j]:
                    return False

                if self.is_large(get_bin(j), get_bin(i)) and f[j] < f[i]:
                    return False

        return True

    def is_large(self, a, b):
        fl = False

        for i in range(len(a)):
            if a[i] == '0' and b[i] == '1':
                return False
            elif a[i] == '1' and b[i] == '0':
                fl = True

        return fl


if __name__ == '__main__':
    get_bin = lambda x: '0' * (3 - len(bin(x)[2:])) + bin(x)[2:]
    a = Solve4()

    func = ['00000000', '10000000', '11000000']

    print(a.solve(*func))