In Takahashi's mind, there is always an integer sequence of length 2 \times 10^9 + 1: A = (A_{-10^9}, A_{-10^9 + 1}, ..., A_{10^9 - 1}, A_{10^9}) and an integer P.

Initially, all the elements in the sequence A in Takahashi's mind are 0, and the value of the integer P is 0.

When Takahashi eats symbols `+`, `-`, `>` and `<`, the sequence A and the integer P will change as follows:

* When he eats `+`, the value of A_P increases by 1;
* When he eats `-`, the value of A_P decreases by 1;
* When he eats `>`, the value of P increases by 1;
* When he eats `<`, the value of P decreases by 1.



Takahashi has a string S of length N. Each character in S is one of the symbols `+`, `-`, `>` and `<`. He chose a pair of integers (i, j) such that 1 \leq i \leq j \leq N and ate the symbols that are the i-th, (i+1)-th, ..., j-th characters in S, in this order. We heard that, after he finished eating, the sequence A became the same as if he had eaten all the symbols in S from first to last. How many such possible pairs (i, j) are there?

Constraints

* 1 \leq N \leq 250000
* |S| = N
* Each character in S is `+`, `-`, `>` or `<`.

Input

Input is given from Standard Input in the following format:


N
S


Output

Print the answer.

Examples

Input

5
+>+<-


Output

3


Input

5
+>+-<


Output

5


Input

48
-+><<><><><>>>+-<<>->>><<><<-+<>><+<<>+><-+->><<


Output

475
#include<iostream>
#include<cstdio>
#include<unordered_map>
using namespace std;
typedef long long ll;
const ll p=1000000000000000009;
const int base=250001;
unordered_map<ll,int> mp;
int n,dig[250005];
__int128 pw[250005]={1},hsh[250005];
ll ans;
char s[250005];
ll qpow(__int128 a,ll b){
    ll res=1;
    while(b){
        if(b&1)
            res=res*a%p;
        a=a*a%p;
        b>>=1;
    }
    return res;
}
__int128 power(int x){
    return x>=0?pw[x]:qpow(pw[-x],p-2);
}
int main(){
    ios::sync_with_stdio(false);
    ll val;
    int i;
    cin>>n>>s+1;
    for(i=1;i<=n;i++)
        pw[i]=pw[i-1]*base%p;
    for(i=1;i<=n;i++){
        switch(s[i]){
            case '+':
                dig[i]=dig[i-1];
                hsh[i]=(hsh[i-1]+power(dig[i]))%p;
                break;
            case '-':
                dig[i]=dig[i-1];
                hsh[i]=(hsh[i-1]-power(dig[i])+p)%p;
                break;
            case '<':
                dig[i]=dig[i-1]+1;
                hsh[i]=hsh[i-1];
                break;
            case '>':
                dig[i]=dig[i-1]-1;
                hsh[i]=hsh[i-1];
        }
    }
    for(i=0;i<=n;i++){
        if(mp.count(hsh[i]))
            ans+=mp[hsh[i]];
        val=(hsh[i]+hsh[n]*power(dig[i]))%p;
        if(mp.count(val))
            mp[val]++;
        else
            mp[val]=1;
    }
    cout<<ans;
    return 0;
}