human
C: Short-circuit evaluation

problem

Naodai-kun and Hokkaido University-kun are playing games. Hokkaido University first generates the following logical formula represented by BNF.

<formula> :: = <or-expr>
<or-expr> :: = <and-expr>
| <or-expr> "|" <and-expr>
<and-expr> :: = <term>
| <and-expr> "&" <term>
<term> :: = "(" <or-expr> ")" | "?"

`&` represents the logical product, `|` represents the logical sum, and `&` is evaluated before `|`.

Naodai reads this formula from the left (as a string), and when he finds a `?`, He does the following:

* If it is certain that the evaluation result of the formula does not change regardless of whether the `?` Is `0` or` 1`, read it without doing anything.
* If not, pay 1 yen to Hokkaido University and replace the `?` With `0` or` 1`.


The logical expression is evaluated as follows. It is a so-called ordinary formula.

(0 &?) == 0
(1 & 0) == 0
(1 & 1) == 1
(0 | 0) == 0
(0 | 1) == 1
(1 |?) == 1

What is the minimum amount Naodai has to pay to finalize the evaluation result of a well-formed formula? Obtain the evaluation result depending on whether it is set to `0` or` 1`.

Input format

A formula that follows the BNF above is given in one line.

Constraint

The length of the formula does not exceed 2 \ times 10 ^ 5.

Output format

Output the minimum amount required to make the evaluation result `0`,` 1`, separated by blanks.

Input example 1

? &? |? &? |? &?

Output example 1

3 2

If you want to make it `0`, rewrite it with` 0 0 0` to make it `0 &? | 0 &? | 0 &?`, If you want to make it `1`, rewrite it with` 1 1` and make it `1 & 1 |? &? |? & It is best to use? `.

Input example 2

? &? &? |? &? &?

Output example 2

twenty three

They are `0 &? &? | 0 &? &?` And `1 & 1 & 1 |? &? &?`, Respectively.

Input example 3

(? |? |?) &? &? &? &? |? &? |? &?

Output example 3

4 4



Example

Input

?&?|?&?|?&?

Output

3 2
Using python3 can you solve the prior task?

=====
Write me a the minimum amount Naodai has to pay to finalize the evaluation result of a well-formed formula?
assistant
#Here is the minimum amount Naodai has to pay to finalize the evaluation result of a well-formed formula.

# from inspect import currentframe
# from sys import exit, stderr

# debug function
# def debug(*args):
#     names = {id(v):k for k,v in currentframe().f_back.f_locals.items()}
#     print(', '.join(names.get(id(arg),'???') + str(id(arg)) +' = '+repr(arg) for arg in args), file=stderr)

src = list(str(input()))
tokens = [tok for tok in src if tok != " "]
# debug(tokens)

# "" as EOF
tokens.append("")
cur = 0
def parse_formula():
    return parse_or()

def parse_or():
    global cur
    lhs = parse_and()
    if tokens[cur] == "|":
        cur += 1
        rhs = parse_or()
        zero = lhs[0] + rhs[0]
        one = min(lhs[1], lhs[0] + rhs[1])
        return (zero, one)
    return lhs

def parse_and():
    global cur
    lhs = parse_term()
    if tokens[cur] == "&":
        cur += 1
        rhs = parse_and()
        zero = min(lhs[0], lhs[1] + rhs[0])
        one = lhs[1] + rhs[1]
        return (zero, one)
    return lhs

def parse_term():
    global cur
    if tokens[cur] == "?":
        cur += 1
        # debug(cur, 1)
        return [1, 1]
    elif tokens[cur] == "(":
        cur += 1
        # debug(cur, "or")
        res = parse_or()
        if tokens[cur] != ")":
            raise Exception("not closed")
        cur += 1
        # debug(cur)
        return res
ans = parse_formula()
print(ans[0], ans[1])
# debug(cur)
# print(len(tokens))