#include <bits/stdc++.h> 

using namespace std;

#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define RFOR(i, a, b) for(int i = (a) - 1; i >= (b); i--)
#define SZ(a) int(a.size())
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
#define F first
#define S second

typedef long long LL;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef double db;

const LL LINF = 1e18 + 44447;
const int N = 1047;
PLL dp[N][N];
string s;
VI idx;
	
void clear(int n)
{
	idx.clear();
	n++;
	FOR (i, 0, n)
	{
		FOR (j, i, n)
		{
			dp[i][j] = {LINF, -LINF};
		}
	}
}

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	
	while (cin >> s)
	{
		clear(SZ(s));
		FOR (i, 0, SZ(s))
		{
			if (s[i] == '+' || s[i] == '-')
				idx.PB(i);
		}
		int n = SZ(s);
		RFOR (l, n, 0)
		{
			FOR (r, l, n + 1)
			{
				if (l >= r || s[r - 1] == '+' || s[r - 1] == '-')
				{
					dp[l][r] = {-LINF, -LINF};
					continue;
				}
				if (s[l] == '+')
				{
					int j = lower_bound(ALL(idx), l) - idx.begin() + 1;
					while (j < SZ(idx) && idx[j] < r)
					{
						PLL& p1 = dp[l + 1][idx[j]];
						PLL& p2 = dp[idx[j]][r];
						j++;
						if (p1.F == -LINF || p2.F == -LINF)
							continue;
						dp[l][r].F = min(dp[l][r].F, p1.F + p2.F);
						dp[l][r].S = max(dp[l][r].S, p1.S + p2.S);
					}
					FOR (i, max(r - 10, l + 1), r + 1)
					{
						PLL& p1 = dp[l + 1][i];
						PLL& p2 = dp[i][r];
						if (p1.F == -LINF || p2.F == -LINF)
							continue;
						dp[l][r].F = min(dp[l][r].F, p1.F + p2.F);
						dp[l][r].S = max(dp[l][r].S, p1.S + p2.S);
					}
				}
				else if (s[l] == '-')
				{
					int j = lower_bound(ALL(idx), l) - idx.begin() + 1;
					while (j < SZ(idx) && idx[j] < r)
					{
						PLL& p1 = dp[l + 1][idx[j]];
						PLL& p2 = dp[idx[j]][r];
						j++;
						if (p1.F == -LINF || p2.F == -LINF)
							continue;
						dp[l][r].F = min(dp[l][r].F, p1.F - p2.S);
						dp[l][r].S = max(dp[l][r].S, p1.S - p2.F);
					}		
					FOR (i, max(r - 10, l + 1), r + 1)
					{
						PLL& p1 = dp[l + 1][i];
						PLL& p2 = dp[i][r];
						if (p1.F == -LINF || p2.F == -LINF)
							continue;
						dp[l][r].F = min(dp[l][r].F, p1.F - p2.S);
						dp[l][r].S = max(dp[l][r].S, p1.S - p2.F);
					}
					PLL& p = dp[l + 1][r];
					if (p.F != -LINF)
					{
						dp[l][r].F = min(dp[l][r].F, -p.S);
						dp[l][r].S = max(dp[l][r].S, -p.F);
					}
				}
				else
				{
					if (l + 1 == r)
					{
						dp[l][r] = {s[l] - '0', s[l] - '0'};
						continue;
					}
					if (s[l] == '0' || r - l > 9)
					{
						dp[l][r] = {-LINF, -LINF};
						continue;
					}
					bool ok =true;
					FOR (i, l, r)
						if (s[i] == '+' || s[i] == '-')
							ok = false;
					if (!ok)
					{
						dp[l][r] = {-LINF, -LINF};
						continue;
					}		
					int x = stoi(s.substr(l, r - l));
					dp[l][r] = {x, x};
				}
			}
		}
		
		auto p = dp[0][SZ(s)];
		cout << p.F << ' ' << p.S << '\n';
	}
	cerr << db(clock()) / CLOCKS_PER_SEC << '\n';
	
	return 0;
}