#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=500+10;
const ll MOD= 998244353;
ll dp[maxn][maxn];
char op[maxn];
int a[maxn];
int sum[maxn];
int main()
{
    int n;
    
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        getchar();
        scanf("%c",&op[i]);
        if(op[i]=='+') {scanf("%d",&a[i]);}
        sum[i]=sum[i-1]+(op[i]=='+');
    }
    ll ans=0;
    for(int x=1;x<=n;x++)
    {
        if(op[x]=='-') continue;//只选择'+'
        memset(dp,0,sizeof(dp));
        dp[0][0]=1;
        for(int i=1;i<=n;i++)
        {
            for(int j=0;j<=sum[i];j++)
            {
                if(x!=i) dp[i][j]=dp[i-1][j];
                if(op[i]=='-')
                {
                    if(i<x)
                    {
                        if(j==0)
                        {
                            dp[i][j]=(dp[i][j]+dp[i-1][j]+dp[i-1][j+1])%MOD;//可能本来就是0，也有可能是1变成了。
                        }
                        else
                        {
                            dp[i][j]=(dp[i][j]+dp[i-1][j+1])%MOD;
                        }
                    }
                    else
                    {
                        //if(j==0) 还是不等0 都是下面这个转移方程所以就不写判断了。
                        dp[i][j]=(dp[i][j]+dp[i-1][j+1])%MOD;
                    }
                    
                }
                else//对于'+'
                {
                    if(a[i]<a[x]||a[i]==a[x]&&i<x)
                    {
                        dp[i][j]=(dp[i][j]+dp[i-1][j-1])%MOD;
                    }
                    else
                    {
                        dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
                    }
                    
                }
            }
        }
        for(int j=0;j<=sum[n];j++) ans=(ans+dp[n][j]*a[x])%MOD;

    }
    printf("%lld\n",ans);
    //system("pause");
	return 0;
}
/*
想法：
我认为的题目：求每种操作后的值。---组合数，
0是没有贡献的。所以我们需要的是有贡献的子序列
但什么时候能代表子序列有贡献？ 在ax下，有值。
1.必须包含第x次操作。（+ ax）
2，设s是集合T种小于ax的元素个数，则保证在每次-操作前，都s必须大于0.
----需要练习，怎么看出是dp----两个未知量的所有情况----所以很像dp。
有多少个满足这些操作的子序列？
设dp[i][j]表示有多少种满足上述条件的子序列。i：表示最后一次操作不晚于i(若i < x则不要求满足第一个条件
j:表示集合T拥有j个小于ax的元素。

dp====从哪边转移过来
*/
### Prompt

Please formulate a Cpp solution to the following problem:

You are given a sequence A, where its elements are either in the form + x or -, where x is an integer.

For such a sequence S where its elements are either in the form + x or -, define f(S) as follows:

  * iterate through S's elements from the first one to the last one, and maintain a multiset T as you iterate through it. 
  * for each element, if it's in the form + x, add x to T; otherwise, erase the smallest element from T (if T is empty, do nothing). 
  * after iterating through all S's elements, compute the sum of all elements in T. f(S) is defined as the sum. 



The sequence b is a subsequence of the sequence a if b can be derived from a by removing zero or more elements without changing the order of the remaining elements. For all A's subsequences B, compute the sum of f(B), modulo 998 244 353.

Input

The first line contains an integer n (1≤ n≤ 500) — the length of A.

Each of the next n lines begins with an operator + or -. If the operator is +, then it's followed by an integer x (1≤ x<998 244 353). The i-th line of those n lines describes the i-th element in A.

Output

Print one integer, which is the answer to the problem, modulo 998 244 353.

Examples

Input


4
-
+ 1
+ 2
-


Output


16

Input


15
+ 2432543
-
+ 4567886
+ 65638788
-
+ 578943
-
-
+ 62356680
-
+ 711111
-
+ 998244352
-
-


Output


750759115

Note

In the first example, the following are all possible pairs of B and f(B):

  * B= {}, f(B)=0. 
  * B= {-}, f(B)=0. 
  * B= {+ 1, -}, f(B)=0. 
  * B= {-, + 1, -}, f(B)=0. 
  * B= {+ 2, -}, f(B)=0. 
  * B= {-, + 2, -}, f(B)=0. 
  * B= {-}, f(B)=0. 
  * B= {-, -}, f(B)=0. 
  * B= {+ 1, + 2}, f(B)=3. 
  * B= {+ 1, + 2, -}, f(B)=2. 
  * B= {-, + 1, + 2}, f(B)=3. 
  * B= {-, + 1, + 2, -}, f(B)=2. 
  * B= {-, + 1}, f(B)=1. 
  * B= {+ 1}, f(B)=1. 
  * B= {-, + 2}, f(B)=2. 
  * B= {+ 2}, f(B)=2. 



The sum of these values is 16.

### Response

```cpp
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=500+10;
const ll MOD= 998244353;
ll dp[maxn][maxn];
char op[maxn];
int a[maxn];
int sum[maxn];
int main()
{
    int n;
    
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        getchar();
        scanf("%c",&op[i]);
        if(op[i]=='+') {scanf("%d",&a[i]);}
        sum[i]=sum[i-1]+(op[i]=='+');
    }
    ll ans=0;
    for(int x=1;x<=n;x++)
    {
        if(op[x]=='-') continue;//只选择'+'
        memset(dp,0,sizeof(dp));
        dp[0][0]=1;
        for(int i=1;i<=n;i++)
        {
            for(int j=0;j<=sum[i];j++)
            {
                if(x!=i) dp[i][j]=dp[i-1][j];
                if(op[i]=='-')
                {
                    if(i<x)
                    {
                        if(j==0)
                        {
                            dp[i][j]=(dp[i][j]+dp[i-1][j]+dp[i-1][j+1])%MOD;//可能本来就是0，也有可能是1变成了。
                        }
                        else
                        {
                            dp[i][j]=(dp[i][j]+dp[i-1][j+1])%MOD;
                        }
                    }
                    else
                    {
                        //if(j==0) 还是不等0 都是下面这个转移方程所以就不写判断了。
                        dp[i][j]=(dp[i][j]+dp[i-1][j+1])%MOD;
                    }
                    
                }
                else//对于'+'
                {
                    if(a[i]<a[x]||a[i]==a[x]&&i<x)
                    {
                        dp[i][j]=(dp[i][j]+dp[i-1][j-1])%MOD;
                    }
                    else
                    {
                        dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
                    }
                    
                }
            }
        }
        for(int j=0;j<=sum[n];j++) ans=(ans+dp[n][j]*a[x])%MOD;

    }
    printf("%lld\n",ans);
    //system("pause");
	return 0;
}
/*
想法：
我认为的题目：求每种操作后的值。---组合数，
0是没有贡献的。所以我们需要的是有贡献的子序列
但什么时候能代表子序列有贡献？ 在ax下，有值。
1.必须包含第x次操作。（+ ax）
2，设s是集合T种小于ax的元素个数，则保证在每次-操作前，都s必须大于0.
----需要练习，怎么看出是dp----两个未知量的所有情况----所以很像dp。
有多少个满足这些操作的子序列？
设dp[i][j]表示有多少种满足上述条件的子序列。i：表示最后一次操作不晚于i(若i < x则不要求满足第一个条件
j:表示集合T拥有j个小于ax的元素。

dp====从哪边转移过来
*/
```