#include<bits/stdc++.h>
using namespace std;
#define V vector
#define pb push_back
#define all1(x) (x).begin() + 1, (x).end()

typedef long long LL;

struct val{
    LL N = 0, LOG = 0, res = 0, integar = 0;
};
val add(val x, val y) {
    assert(x.integar == 0 || y.integar == 0);
    if(x.integar) return y;
    if(y.integar) return x;

    if(x.N < y.N) swap(x, y);
    if(x.N > y.N) return x;

    if(x.LOG < y.LOG) swap(x, y);
    if(x.LOG > y.LOG) return x;

    if(x.res < y.res) swap(x, y);
    return x;
}

val mul(val x, val y) {
    assert(x.integar == 0 || y.integar == 0);
    if(x.integar) return y;
    if(y.integar) return x;
    
    x.N += y.N;
    x.LOG += y.LOG;
    x.res |= y.res;
    return x;
}

val power(val x, val y) {
    assert(x.integar == 0 && y.integar && (x.N == 1 && x.LOG == 0 && x.res == 0 
    || x.N == 0 && (x.LOG == 1 && x.res == 0 || x.res == 1 && x.LOG == 0)));

    x.N *= y.integar;
    x.LOG *= y.integar;
    return x;
}

val log_op(val x) {
    assert(x.integar == 0);
    if(x.N) return {0, 1, 0, 0};
    return {0, 0, 1, 0};
}

struct op_bin_val {
    val v;
    char optype = 0;
    int priority = 0;
};

int get_pri(char c) {
    if(c == '+') return 1;
    if(c == '*') return 2;
    if(c == '^') return 3;
    if(c == 'l') return 4;
    assert(0);
}

bool is_val(char c) {
    if(c >= '0' && c <= '9' || c == 'N') return 1;
    return 0;
}
bool is_useless(char c) {
    if(c == '(' || c == ')' || c == 'o' || c == 'g') return 1;
    return 0;
}
bool is_op(char c) {
    if(!is_val(c) && !is_useless(c)) return 1;
    return 0;
}

void show(val x) {
    cout << "N, LOG, res, integer : " << x.N << " " << x.LOG << " " << x.res << " " << x.integar << endl;
}

void solve() {
    string s; cin >> s;

    V<int> priority_base(s.size());
    for(int i = 0; i < s.size(); i++) {
        if(i) priority_base[i] = priority_base[i - 1];
        if(s[i] == '(') priority_base[i]++;
        if(s[i] == ')') priority_base[i]--;
    }

    V<op_bin_val> stk;

    auto deal_end = [&]() {

        if(stk.size() == 1) {
            assert(stk.back().optype == 'l');
            stk.back().v = log_op(stk.back().v);
            stk.back().priority = 0;
            stk.back().optype = 0;
            return;
        }


        if(stk.back().optype == 'l') {
            val v = log_op(stk.back().v);
            stk.pop_back();
            stk.back().v = v;
        } else if(stk.back().optype == '*') {
            val v = mul(stk[stk.size() - 2].v, stk.back().v);
            stk.pop_back();
            stk.back().v = v;
        } else if(stk.back().optype == '+') {
            val v = add(stk[stk.size() - 2].v, stk.back().v);
            stk.pop_back();
            stk.back().v = v;
        } else if(stk.back().optype == '^') {
            val v = power(stk[stk.size() - 2].v, stk.back().v);
            stk.pop_back();
            stk.back().v = v;
        } else assert(0);
    };
    for(int i = 0; i < s.size(); i++) {
        if(is_useless(s[i])) continue;

        op_bin_val now;

        // cout << "i : " << i << endl;
        // show(now.v);
        if(is_val(s[i])) {
            if(s[i] == 'N') now.v = {1, 0, 0, 0};
            else {
                int r = i;
                while(r + 1 < s.size() && is_val(s[r + 1])) r++;
                now.v = {0, 0, 0, stoi(s.substr(i, r - i + 1))};
                i = r;
            }
        } else {
            now.priority = priority_base[i] * 10 + get_pri(s[i]);
            now.optype = s[i];
            int l = i + 1;
            while(l < s.size() && is_useless(s[l])) l++;
            assert(l < s.size());
            i = l;
            // cout << "l at : " << l << endl;
            // show(now.v);
            if(is_val(s[l])) {
                if(s[l] == 'N') now.v = {1, 0, 0, 0};
                else {
                    int r = l;
                    while(r + 1 < s.size() && is_val(s[r + 1])) r++;
                    now.v = {0, 0, 0, stoi(s.substr(l, r - l + 1))};
                    i = r;
                }
            } else i--;
        }

        // cout << i

        // cout << "priority : " << now.priority << endl;
        // cout << "optype : " << now.optype << endl;
        // cout << "v : "; show(now.v); cout << endl;

        while(stk.size() >= 2 && stk.back().priority >= stk[stk.size() - 2].priority && stk.back().priority >= now.priority
            || stk.size() == 1 && stk.back().optype == 'l' && stk.back().priority >= now.priority) {
            deal_end();
        }
        stk.push_back(now);
    }

    while(stk.size() >= 2) {
        assert(stk.back().priority > stk[stk.size() - 2].priority);
        deal_end();
        // show(stk.back().v);
    }

    if(stk.back().optype == 'l') {
        stk.back().v = log_op(stk.back().v);
    }

    cout << stk.back().v.N << " " << stk.back().v.LOG + stk.back().v.res << endl;
}
int main() {
    ios::sync_with_stdio(0), cin.tie(0);
    solve();
}