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.
import java.io.*;
import java.math.BigInteger;
import java.util.*;


//Mann Shah [ DAIICT ].
//fast io

public class Main {
	public static long mod = (long) (1e9 + 7);
	public static long inf = (long) 1e15 + 42;
	static InputReader in;
	static PrintWriter out;

	public static long gcd(long a, long b) {
		if (a == 0)
			return b;
		return gcd(b % a, a);
	}
	public static long power(long x, long y, long p) // x to power y mod p;
    { 
        long res = 1;      
        x = x % p;  
        while (y > 0) { 
            if((y & 1)==1) 
                res = (res * x) % p; 
            y = y >> 1;  
            x = (x * x) % p;  
        } 
        return res; 
    } 
	
	public static void main(String args[]) {

		in = new InputReader(System.in);
		out = new PrintWriter(System.out);
	
		int n = in.nextInt();
		String s = in.readString();
		out.println(n+1);
		
		out.close();
	}

	// check Int overflow
	// check n=0/1 case & init of A or use lists.
	
	/* TC space



	 */
	
	static class InputReader {

		private final InputStream stream;
		private final byte[] buf = new byte[8192];
		private int curChar, snumChars;
		private SpaceCharFilter filter;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		public int snext() {
			if (snumChars == -1)
				throw new InputMismatchException();
			if (curChar >= snumChars) {
				curChar = 0;
				try {
					snumChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (snumChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public int nextInt() {
			int c = snext();
			while (isSpaceChar(c)) {
				c = snext();
			}
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public long nextLong() {
			int c = snext();
			while (isSpaceChar(c)) {
				c = snext();
			}
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int[] nextIntArray(int n) {
			int a[] = new int[n];
			for (int i = 0; i < n; i++) {
				a[i] = nextInt();
			}
			return a;
		}
		
		public ArrayList<Integer> nextArrayList(int n){
			ArrayList<Integer> a = new ArrayList<Integer>();
			for(int i=0;i<n;i++) {
				int x = nextInt();
				a.add(x);
			}
			return a;
		}

		public long[] nextLongArray(int n) {
			long a[] = new long[n];
			for (int i = 0; i < n; i++) {
				a[i] = nextLong();
			}
			return a;
		}

		public String readString() {
			int c = snext();
			while (isSpaceChar(c)) {
				c = snext();
			}
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = snext();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public String nextLine() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = snext();
			} while (!isEndOfLine(c));
			return res.toString();
		}

		public boolean isSpaceChar(int c) {
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		private boolean isEndOfLine(int c) {
			return c == '\n' || c == '\r' || c == -1;
		}

		public interface SpaceCharFilter {
			public boolean isSpaceChar(int ch);
		}

	}

}

// For Pair sorting

// Arrays.sort(arr,new Comparator<Pair>() {
// @Override public int compare(Pair p1, Pair p2)
// {
// return p1.x - p2.x;
// }
// });

class Pair {
	int x;
	int y;

	// Constructor
	public Pair(int x, int y) {
		this.x = x;
		this.y = y;
	}
	
	@Override
	public boolean equals(Object o) {
		Pair p =(Pair)o;
		return (x==p.x && y==p.y);
	}
}

class x{
	//declare variables
	int abc;
	
	//constructor
	public x(int abc) {
		this.abc = abc;
	}
	
}


class couple implements Comparable<couple> {
	int x, y;

	public couple(int m, int f) {
		x = m;
		y = f;
	}

	public int compareTo(couple o) {

		return x - o.x;
	}
}