Problem: Today, Mezo is playing a game. Zoma, a character in that game, is initially at position x = 0. Mezo starts sending n commands to Zoma. There are two possible commands:

  * 'L' (Left) sets the position x: =x - 1; 
  * 'R' (Right) sets the position x: =x + 1. 



Unfortunately, Mezo's controller malfunctions sometimes. Some commands are sent successfully and some are ignored. If the command is ignored then the position x doesn't change and Mezo simply proceeds to the next command.

For example, if Mezo sends commands "LRLR", then here are some possible outcomes (underlined commands are sent successfully): 

  * "LRLR" — Zoma moves to the left, to the right, to the left again and to the right for the final time, ending up at position 0; 
  * "LRLR" — Zoma recieves no commands, doesn't move at all and ends up at position 0 as well; 
  * "LRLR" — Zoma moves to the left, then to the left again and ends up in position -2. 



Mezo doesn't know which commands will be sent successfully beforehand. Thus, he wants to know how many different positions may Zoma end up at.

Input

The first line contains n (1 ≤ n ≤ 10^5) — the number of commands Mezo sends.

The second line contains a string s of n commands, each either 'L' (Left) or 'R' (Right).

Output

Print one integer — the number of different positions Zoma may end up at.

Example

Input


4
LRLR


Output


5

Note

In the example, Zoma may end up anywhere between -2 and 2.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
ifstream fin;
ofstream fout;
class dsu {
 private:
  vector<int> p, rank;
  int ns;

 public:
  dsu(int N) {
    rank.assign(N, 0);
    p.assign(N, 0);
    ns = N;
    for (int i = 0; i < N; i++) {
      p[i] = i;
    }
  }
  int findSet(int s1) {
    if (p[s1] == s1) {
      return s1;
    } else {
      int fs = findSet(p[s1]);
      p[s1] = fs;
      return fs;
    }
  }
  bool isSameSet(int s1, int s2) { return findSet(s1) == findSet(s2); }
  void unionSet(int s1, int s2) {
    if (!isSameSet(s1, s2)) {
      ns--;
      int x = findSet(s1);
      int y = findSet(s2);
      if (rank[x] > rank[y]) {
        p[y] = x;
      } else {
        p[x] = y;
        if (rank[x] == rank[y]) {
          rank[y]++;
        }
      }
    }
  }
  int numSets() { return ns; }
};
long long gcd(long long a, long long b) {
  if (a > b) {
    long long oa = a;
    a = b;
    b = oa;
  }
  if (b == 0) {
    return a;
  }
  return gcd(b, a % b);
}
vector<int> readList(int n) {
  vector<int> a;
  for (int i = 0; i < n; i++) {
    int b;
    cin >> b;
    a.push_back(b);
  }
  return a;
}
void printList(vector<long long> l) {
  int n = ((int)l.size());
  for (int i = 0; i < n; i++) {
    cout << l[i];
    if (i < n - 1) {
      cout << " ";
    } else {
      cout << endl;
    }
  }
}
vector<vector<int> > readGraph(int n, int m) {
  vector<vector<int> > al;
  for (int i = 0; i < n; i++) {
    vector<int> c;
    al.push_back(c);
  }
  for (int i = 0; i < m; i++) {
    int a, b;
    scanf("%d%d", &a, &b);
    al[a - 1].push_back(b - 1);
    al[b - 1].push_back(a - 1);
  }
  return al;
}
vector<bool> vis;
vector<int> gf[200010];
int dfs(int n, vector<vector<int> > al) {
  vis[n] = true;
  int sz = 1;
  for (int i = 0; i < al[n].size(); i++) {
    if (!vis[al[n][i]]) {
      sz += dfs(al[n][i], al);
    }
  }
  return sz;
}
pair<int, int> swap(pair<int, int> p) {
  int a = p.first;
  int b = p.second;
  return make_pair(b, a);
}
vector<int> prime_factors(int n) {
  int sq = (int)(sqrt(n));
  for (int i = 2; i < sq + 1; i++) {
    if (n % i == 0) {
      vector<int> c = prime_factors(i);
      vector<int> d = prime_factors(n / i);
      for (int i = 0; i < d.size(); i++) {
        c.push_back(d[i]);
      }
      return c;
    }
  }
  vector<int> c;
  c.push_back(n);
  return c;
}
int comp(int a, int b) {
  if (a > b) {
    return 1;
  } else if (a == b) {
    return 0;
  }
  return -1;
}
void solve() {
  int n;
  cin >> n;
  string s;
  cin >> s;
  cout << n + 1 << endl;
}
void querySolve() {
  int t;
  scanf("%d", &t);
  for (int i = 0; i < t; i++) {
    solve();
  }
}
int main() { solve(); }