#include <iostream>
#include <map>
#include <vector>
#include <functional>
#include <memory>
#include <numeric>

struct EvalBracket
{
    using IntPtr = std::shared_ptr<int>;
    using IncrementFunc = std::function<IntPtr()>;

    void AddBracket( char openBracket, char closeBracket )
    {
        auto counter = std::make_shared<int>(0);
        m_brackets[openBracket]  = [counter]()
        {
            if( (*counter) >= 0 )
            {
                (++(*counter));
            }
            return counter;
        };

        m_brackets[closeBracket] = [counter]()
        {
            (--(*counter));
            return counter;
        };

        m_counters.emplace_back(std::move(counter));
    }

    bool Evaluate(const std::string& expression)
    {
        for(const auto& counter : m_counters)
        {
            (*counter) = 0;
        }

        for(auto c : expression)
        {
            auto iter = m_brackets.find(c);
            if( iter != m_brackets.end() )
            {
                iter->second();
            }
        }

        bool result = true;
        for(const auto& counter : m_counters)
        {
            result &= (*counter) == 0;
        }
        return result;
    }

private:
    std::vector<IntPtr> m_counters;
    std::map<char, IncrementFunc> m_brackets;
};

int main()
{
    std::string expression;
    std::cin >> expression;

    std::vector<int> counter(3, 0);
    for(char c : expression)
    {
        if(counter[0] >= 0){ counter[0] += (c == '{') ? 1 : (c == '}') ? (-1) : 0; }
        if(counter[1] >= 0){ counter[1] += (c == '[') ? 1 : (c == ']') ? (-1) : 0; }
        if(counter[2] >= 0){ counter[2] += (c == '(') ? 1 : (c == ')') ? (-1) : 0; }
    }

    bool result = true;
    for(auto c : counter)
    {
        if( c != 0 )
        {
            result = false;
            break;
        }
    }

    std::cout << std::boolalpha << result << std::endl;

    return 0;
}