import java.util.Scanner;
import java.util.Stack;

public class Solution {

    private static final char KEY_OPENS_BRACKET = '{';
    private static final char KEY_CLOSES_BRACKET = '}';
    private static final char PARENTHESIS_OPENS_BRACKET = '(';
    private static final char PARENTHESIS_CLOSES_BRACKET = ')';
    private static final char SQUARE_PARENTHESIS_OPENS_BRACKET = '[';
    private static final char SQUARE_PARENTHESIS_CLOSES_BRACKET = ']';

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while(scanner.hasNext()){
            Stack<Character> stack = new Stack<>();
            String input = scanner.nextLine();
            System.out.println(isValid(input, stack));
        }
        scanner.close();
    }

    private static boolean isValid(String input, Stack<Character> stack) {
        for(char chr : input.toCharArray()) {
            if(isOpenBracket(chr)) {
                stack.push(chr);
                continue;
            }
            if(chr == KEY_CLOSES_BRACKET  && !stack.isEmpty() && stack.peek() == KEY_OPENS_BRACKET) {
                stack.pop();
                continue;
            }
            if(chr == PARENTHESIS_CLOSES_BRACKET && !stack.isEmpty() && stack.peek() == PARENTHESIS_OPENS_BRACKET) {
                stack.pop();
                continue;
            }
            if (chr == SQUARE_PARENTHESIS_CLOSES_BRACKET &&!stack.isEmpty() && stack.peek() == SQUARE_PARENTHESIS_OPENS_BRACKET) {
                stack.pop();
                continue;
            }
            if (isCloseBracket(chr)) {
                stack.push(chr);
                break;
            }
        }
        return stack.isEmpty();
    }

    private static boolean isOpenBracket(char chr) {
        return switch (chr) {
            case KEY_OPENS_BRACKET, PARENTHESIS_OPENS_BRACKET, SQUARE_PARENTHESIS_OPENS_BRACKET -> true;
            default -> false;
        };
    }

    private static boolean isCloseBracket(char chr) {
        return switch (chr) {
            case KEY_CLOSES_BRACKET, PARENTHESIS_CLOSES_BRACKET, SQUARE_PARENTHESIS_CLOSES_BRACKET -> true;
            default -> false;
        };
    }
}

import java.io.*;
import java.util.*;

public class Solution {

    public static void main(String[] args) {
        /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
        Scanner input = new Scanner(System.in); 
        while(input.hasNext()) {
            String line = input.nextLine(); 
            Stack<Character> lineStak = new Stack<>(); 
            for (char chars : line.toCharArray()) {
                if(lineStak.empty()) {
                    lineStak.push(chars); 
                }
                else if (balanced(lineStak.peek(), chars)) lineStak.pop(); 
                else lineStak.push(chars);  
            }
            System.out.println(lineStak.empty());
            
        }
    }
    
    public static boolean balanced(char c1, char c2 ) {
        
        return 
            (c1 == '{' && c2 == '}') ||
            (c1 == '(' && c2 == ')') ||
            (c1 == '[' && c2 == ']')
        ;  
    }
}

import java.util.*;
class Solution{
	
	public static void main(String []argh)
	{
		Scanner sc = new Scanner(System.in);
		
		while (sc.hasNext()) {
			String input=sc.next();
            //Complete the code
            System.out.println(isBalanced(input));
		}
		
	}
    
    private static boolean isBalanced(String input) {
        if(input.length() == 0) {
            return true;
        }
        Stack<Character> stack = new Stack<>();
        for(Character c: input.toCharArray()) {
            switch(c) {
                case '(' :
                case '{' :
                case '[' :
                    stack.add(c);
                    break;
                case ')' :
                    if (stack.isEmpty() || !stack.pop().equals('('))
                        return false;
                    break;
                case '}' :
                    if (stack.isEmpty() || !stack.pop().equals('{'))
                        return false;
                    break;
                case ']' :
                    if (stack.isEmpty() || !stack.pop().equals('['))
                        return false;
                    break;
                default:
                    return false;
            }
        }
        
        return stack.isEmpty();
    }
}

import java.util.Deque;
import java.util.LinkedList;
import java.util.Map;
import java.util.Scanner;

class Solution {

    private static final Map<Character, Character> brackets = Map.of(
        ')', '(',
        '}', '{',
        ']', '['
    );
    
    private static boolean check(String input) {
        Deque<Character> stack = new LinkedList<>();

        for (char c : input.toCharArray()) {
            if (brackets.containsKey(c)) {
                if (stack.isEmpty()) return false;

                if (brackets.get(c) != stack.removeLast()) return false;

                continue;
            }

            stack.add(c);
        }

        return stack.isEmpty();
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        while (sc.hasNext()) {
            boolean isBalanced = check(sc.next());

            System.out.println(isBalanced ? "true" : "false");
        }

        sc.close();
    }
}