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 \le n \le 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$.

Difficulty: EASY

Solutions:
_ = input()
string = input()
print(len(string) + 1)


n = int(input())
seq = input()
L = 0
R = 0
for i in range(n):
	if seq[i] == 'L':
		L = L - 1
	else:
		R = R + 1
print(R - L + 1)


n = int(input())
s = input()
kL = 0
kR = 0
for i in s:
	if i == 'L':
		kL += 1
	if i == 'R':
		kR += 1
print(kL + kR + 1)


n = int(int(input()))
s = input()
left = s.count('L')
right = s.count('R')
print(left + right + 1)


import sys
r_input = sys.stdin.readline
n = int(r_input())
s = r_input().rstrip()
print(s.count('L') + s.count('R') + 1)


n = int(input())
s = input()
l = s.count('L')
r = n - l
print(l + r + 1)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
mod2 = 998244353
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def main():
	t = 1
	rr = []
	for _ in range(t):
		n = I()
		s = S()
		rr.append(n + 1)
	return JA(rr, '\n')
print(main())


n = int(input())
st = input()
cnt1 = 0
cnt2 = 0
for i in range(0, n):
	if st[i] == 'L':
		cnt1 += 1
	else:
		cnt2 += 1
print(cnt1 + cnt2 + 1)


import sys
sys.setrecursionlimit(10000000)
mod = 10 ** 9 + 7
INF = float('inf')
from sys import stdin
readline = stdin.readline

def readInts():
	return list(map(int, readline().split()))

def readTuples():
	return tuple(map(int, readline().split()))

def I():
	return int(readline())
n = I()
S = input()
l = 0
r = 0
for s in S:
	if s == 'L':
		l -= 1
	elif s == 'R':
		r += 1
print(r - l + 1)


import sys
import math
from collections import defaultdict, Counter
n = int(input())
s = input()
left = 0
right = 0
for j in s:
	if j == 'L':
		left += 1
	else:
		right += 1
print(left + right + 1)


from collections import Counter as c
n = int(input())
string = input()
Controls = c(string)
a = Controls['L']
b = Controls['R']
print(a + b + 1)


n = int(input())
string = input()
countL = 0
countR = 0
for i in string:
	if i == 'L':
		countL += 1
	else:
		countR += 1
print(countR + countL + 1)


n = int(input())
s = input()
print(int(n + 1))


n = int(input())
s = input()
a = s.count('L') + s.count('R') + 1
print(a)


import sys
input = sys.stdin.readline
n = int(input().strip())
s = input().strip()
print(len(s) + 1)


number = input()
string = input()
print(int(number) + 1)


input()
s = input()
print(1 + s.count('L') + s.count('R'))


a = int(input())
input()
print(a + 1)


_ = input()
s = input()
l = sum([c == 'L' for c in s])
r = sum([c == 'R' for c in s])
print(l + r + 1)


def iinput():
	return [int(i) for i in input().split()]
n = int(input())
a = input()
(L, R) = (0, 0)
for i in a:
	if i == 'L':
		L += 1
	else:
		R += 1
print(L + R + 1)


def f(A):
	N = len(A)
	t = 0
	b = 0
	for i in range(len(A)):
		if A[i] == 'L':
			t += 1
		elif A[i] == 'R':
			b += 1
	return t + b + 1
N = int(input())
A = input()
print(f(A))


def sol():
	num = input()
	inp = input()
	lCount = 0
	rCount = 0
	counter = 0
	for i in range(0, len(inp)):
		if inp[i].lower() == 'l':
			lCount += 1
		elif inp[i].lower() == 'r':
			rCount += 1
	return rCount + lCount + 1
print(sol())


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
n = int(input())
string1 = input()
print(n + 1)


def score():
	n = int(input())
	s = input()
	counter_left = s.count('L')
	counter_right = s.count('R')
	print(counter_right - -counter_left + 1)
score()


n = int(input())
st = input()
l = st.count('L')
r = st.count('R')
print(l + r + 1)


n = input()
comandos = input()
count_L = 0
count_R = 0
for i in comandos:
	if i == 'L':
		count_L = count_L + 1
	else:
		count_R = count_R + 1
print(count_R + count_L + 1)


n = int(input())
s = input()
c = 0
d = 0
for i in s:
	if i == 'L':
		c += 1
	else:
		d += 1
print(c + d + 1)


from collections import Counter
from collections import Counter

def solve():
	n = input()
	string = input()
	count = Counter(string)
	return count['R'] * 1 - count['L'] * -1 + 1
print(solve())


import re
input()
s = input()
x = re.findall('L', s)
y = re.findall('R', s)
print(len(x) + len(y) + 1)


def zoma(s):
	ll = 0
	rr = 0
	init = 1
	poss = 0
	for i in range(len(s)):
		if s[i] == 'L':
			ll += 1
		else:
			rr += 1
	poss = ll + rr + init
	return poss
n = int(input())
s = input()
ans = zoma(s)
print(ans)


n = int(input())
s = input()
a = [0, 0]
for i in s:
	if i == 'L':
		a[0] += 1
	else:
		a[1] += 1
print(sum(a) + 1)


from sys import stdin
input = stdin.readline
print(int(input()) + 1)


t = int(input())
string = input()
L = 0
R = 0
for i in string:
	if i == 'L':
		L += 1
	else:
		R += 1
print(1 + R + L)


def main():
	N = int(input())
	S = str(input())
	print(len(S) + 1)
main()


amountOfMoves = int(input())
print(amountOfMoves + 1)


t = int(input())
s = input()
l = 0
r = 0
for x in range(t):
	if s[x] == 'L':
		l += 1
	elif s[x] == 'R':
		r += 1
print(r + l + 1)


n = int(input())
str = input()
ls = str.count('L')
rs = str.count('R')
print(ls + rs + 1)


n = int(input())
d = input()
left = 0
right = 0
for a in d:
	if a == 'L':
		left += 1
	if a == 'R':
		right += 1
print(left + right + 1)


n = input()
commands = input()
l = 0
r = 0
for c in commands:
	if c == 'L':
		l += 1
	else:
		r += 1
print(abs(l) + abs(r) + 1)


def mezo(l):
	leftMax = l.count('L')
	rightMax = l.count('R')
	print(leftMax + rightMax + 1)
command = eval(input())
pos = input()
mezo(pos)


n = int(input())
a = input()
print(n + 1)


input()
p = input()
print(1 + p.count('R') + p.count('L'))


n = int(input())
a = input()
l = 0
r = 0
for i in a:
	if i == 'L':
		l += 1
	else:
		r += 1
print(r + l + 1)


def positions(s):
	l = s.count('L')
	r = s.count('R')
	val = l + r + 1
	return val
n = int(input())
s = input()
print(positions(s))


n = int(input())
s = input()
rcnt = s.count('R')
lcnt = s.count('L')
if lcnt == 0:
	print(rcnt + 1)
elif rcnt == 0:
	print(lcnt + 1)
else:
	print(abs(lcnt) + rcnt + 1)


n = int(input())
k = str(input())
cl = 0
cr = 0
for i in range(len(k)):
	if k[i] == 'L':
		cl -= 1
	else:
		cr += 1
print(cr - cl + 1)


n = int(input())
print(n + 1)


n = int(input())
command = input()
ls = command.count('L')
rs = command.count('R')
print(rs + ls + 1)


def mezoPlayingZoma(givenInput):
	moveLeftNum = moveRightNum = 0
	for each in givenInput:
		if each is 'L':
			moveLeftNum += 1
		else:
			moveRightNum += 1
	result = moveLeftNum + moveRightNum + 1
	return result
n = eval(input())
givenInput = str(n) + '\n'
singleLine = input()
numOfPossibleLocations = mezoPlayingZoma(singleLine)
print(numOfPossibleLocations)


a = int(input())
b = input()
c = a + 1
print(c)


n = int(input())
k = list(map(str, input().strip().split()))[:n]
print(n + 1)


input()
C = input()
L = R = 0
for c in C:
	L += c == 'L'
	R += c == 'R'
print(L + R + 1)


n = int(input())
s = input()
print(abs(s.count('L') + s.count('R')) + 1)


n = int(input())
s = input()
rcnt = s.count('R')
lcnt = s.count('L')
print(abs(lcnt) + rcnt + 1)


commands = int(input())
string = input()
L = 0
R = 0
for letter in string:
	if letter == 'L':
		L += 1
	else:
		R += 1
print(L + R + 1)


n = int(input())
x = input()
x1 = x.count('L')
x2 = x.count('R')
print(x1 + x2 + 1)


import sys
input = sys.stdin.readline
I = input
n = int(input())
s = input()
l = s.count('L')
r = s.count('R')
print(l + r + 1)


import sys
print(int(sys.stdin.readline()) + 1)


n = int(input())
s = input()
l = s.count('L')
r = s.count('R')
tot = abs(l) + abs(r) + 1
print(tot)


inp1 = int(input()) + 1
inp = input()
print(inp1)


n = int(input())
string = input()
l = 0
r = 0
for j in range(n):
	if string[j] == 'L':
		l = l + 1
	else:
		r = r + 1
print(l + r + 1)


t = int(input())
s = input()
l = 0
r = 0
for i in s:
	if i == 'L':
		l += 1
	if i == 'R':
		r += 1
print(l + r + 1)


n = int(input())
a = str(input())
m = a.count('L')
r = a.count('R')
print(r + m + 1)


n = int(input())
k = input()[:n]
l1 = k.count('L')
l2 = k.count('R')
print(l1 + l2 + 1)


n = int(input())
st = str(input())
print(n + 1)


turn = int(input())
command = str(input())
num_of_commands = len(command)
print(num_of_commands + 1)


n_commands = input()
commands = input()
possible_pos = []
pos = 0
for command in commands:
	if command == 'L':
		pos -= 1
	else:
		pos += 1
possible_pos.append(pos)
pos = 0
for command in commands:
	if command == 'L':
		pos -= 1
possible_pos.append(pos)
pos = 0
for command in commands:
	if command == 'R':
		pos += 1
possible_pos.append(pos)
max = 0
min = 0
for pos in possible_pos:
	if pos > max:
		max = pos
	if pos < min:
		min = pos
total = 0
for i in range(min, max + 1):
	total += 1
print(total)


n = int(input())
s = input()
r = 0
k = 0
for i in range(n):
	if s[i] == 'R':
		r += 1
	else:
		k += 1
print(r + 1 + k)


n = int(input())
l = [*input()]
(nr, nl) = (0, 0)
for i in l:
	if i == 'L':
		nl += 1
	else:
		nr += 1
print(nr + nl + 1)


def init():
	t = int(input())
	input()
	print(t + 1)
init()


n = int(input())
s = input()
lcount = 0
rcount = 0
for i in range(n):
	if s[i] == 'L':
		lcount += 1
	elif s[i] == 'R':
		rcount += 1
if lcount == 0:
	print(rcount + 1)
elif rcount == 0:
	print(lcount + 1)
else:
	print(lcount + rcount + 1)


n = int(input())
s = str(input())
s1 = list(s)
k1 = s1.count('L')
k2 = s1.count('R')
print(k1 + k2 + 1)


n = int(input())
commands = []
ipt = input()
for i in range(len(ipt)):
	commands.append(ipt[i])
x1 = 0 - commands.count('L')
x2 = 0 + commands.count('R')
x = x2 - x1
print(x + 1)


n = int(input())
s = input()
count = 0
count1 = 0
for i in range(len(s)):
	if s[i] == 'L':
		count += 1
	else:
		count1 += 1
print(abs(count) + abs(count1) + 1)


n = input()
command = input()
m_b = 0
p_b = 0
for c in command:
	if c == 'L':
		m_b += -1
	else:
		p_b += 1
print(p_b - m_b + 1)


def main():
	n = int(input())
	s = input()
	left = 0 - s.count('L')
	right = 0 + s.count('R')
	print(right - left + 1)
main()


n = input()
ch = input()
count_l = ch.count('L')
count_r = ch.count('R')
print(count_l + count_r + 1)


def mi():
	return list(map(int, input().split()))
n = int(input())
s = list(input())
l = s.count('L')
r = n - l
print(r + l + 1)


n = int(input())
commands = input()
print(commands.count('L') + commands.count('R') + 1)


t = int(input())
k = str(input())
print(len(k) + 1)


t = int(input())
a = input()
x = 0
y = 0
for i in range(len(a)):
	if a[i] == 'L':
		x -= 1
	elif a[i] == 'R':
		y += 1
print(y - x + 1)


n = int(input())
cmd = input()
l = 0
r = 0
for i in range(len(cmd)):
	if cmd[i] == 'L':
		l += 1
	else:
		r += 1
print(r + l + 1)


try:
	while True:
		n = int(input())
		string = input()
		ls = 0
		rs = 0
		for char in string:
			if char == 'L':
				ls += 1
			if char == 'R':
				rs += 1
		print(ls + rs + 1)
except EOFError:
	pass


a = int(input())
b = input()
cl = 0
cr = 0
s = 0
for i in range(a):
	if b[i] == 'L':
		cl += 1
		s += 1
	if b[i] == 'R':
		cr += 1
		s += 1
s += 1
print(s)


n = int(input())
cad = input()
print(len(cad) + 1)


from collections import Counter
n = int(input())
counter = Counter(input())
print(counter['L'] + counter['R'] + 1)


(n, moves) = (int(input()), input())
usethis = []
string = ''
if n % 2 == 0:
	for i in range(0, n, 2):
		if moves[i] + moves[i + 1] not in {'LR', 'RL'}:
			string += moves[i] + moves[i + 1]
else:
	for i in range(1, n, 2):
		if moves[i] + moves[i - 1] not in {'LR', 'RL'}:
			string += moves[i] + moves[i + 1]
(rs, ls) = ([i for i in moves if i in ['l', 'L']], [i for i in moves if i in ['R', 'r']])
(x, y) = (len(ls) * -1, len(rs))
print(abs(x) + abs(y) + 1)


input()
X = input()
mi = -X.count('L')
ma = X.count('R')
print(ma - mi + 1)


n = int(input())
s = input()[:n]
s = list(s)
l = s.count('L')
R = s.count('R')
i = 0 - l * 1
c = 0
while i <= R:
	c += 1
	i += 1
print(c)


esqu = 0
dire = 0
num = int(input())
stri = input()
for i in stri:
	if i == 'L':
		esqu = esqu + 1
	else:
		dire = dire + 1
print(dire + esqu + 1)


n = int(input())
m = input()
print(n + 1)


from sys import stdin
inp = lambda : stdin.readline().strip()
n = int(inp())
a = int()
print(n + 1)


import sys
import math
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
n = inp()
s = insr()
lc = s.count('L')
rc = s.count('R')
print(lc + rc + 1)


n = int(input())
s = input()
(L, R) = (0, 0)
for i in s:
	if i == 'L':
		L += 1
	elif i == 'R':
		R += 1
print(L + R + 1)


n = int(input())
s = input()
a = s.count('L')
b = s.count('R')
print(abs(a + b) + 1)


n = int(input())
a = input()
l = a.count('L')
r = a.count('R')
print(l + r + 1)


n = int(input().strip(' '))
cmnds = input().strip(' ')
intl = 1
print(n + 1)


p = 0
q = 0
x = input()
s = input()
for i in s:
	if i == 'L':
		p = p - 1
	else:
		q = q + 1
print(q - p + 1)


n = int(input())
s = str(input())
l = s.count('L')
r = s.count('R')
print(l + r + 1)


charNum = int(input())
string = input()
print(string.count('R') + string.count('L') + 1)


n = int(input())
ml = list(map(str, input()))
print(n + 1)


n = int(input())
s = input()
arr = list(s)
left = arr.count('L')
right = arr.count('R')
print(left + right + 1)


n = int(input())
comm = input()
print(n + 1)


n = int(input())
di = input()
ans = 0
l = 0
r = 0
for i in range(0, n):
	if di[i] == 'L':
		l += 1
	else:
		r += 1
ans = r + l + 1
print(ans)


n = int(input())
c = input()
print(n + 1)


T = int(input())
S = input()
print(len(S) + 1)


t = int(input())
x = input()
x = list(x)
k = x.count('L')
m = x.count('R')
print(k + m + 1)


n = input()
s = input()
l = s.count('L')
r = s.count('R')
print(l + r + 1)


size = int(input())
string = input()
print(size + 1)


n = int(input())
comm = input()
left = 0
right = 0
for l in comm:
	if l == 'L':
		left += 1
	else:
		right += 1
result = left + right + 1
print(result)


n = int(input())
txt = input()
x = txt.count('L')
y = txt.count('R')
print(int(x + y) + int(1))


n = int(input())
str1 = input()
print(len(str1) + 1)


import math
n = int(input())
s = input()
flag1 = flag2 = 0
for i in range(0, n):
	if s[i] == 'L':
		flag1 += 1
	else:
		flag2 += 1
print(flag1 + flag2 + 1)


n = int(input())
ch = input()
print(n + 1)


y = int(input())
x = input()
c = x.count('L') + x.count('R')
print(c + 1)


n = int(input())
s = input()
l = 0
r = 0
for i in range(len(s)):
	if s[i] == 'L':
		l += 1
	else:
		r -= 1
print(abs(r - l) + 1)


n = int(input())
s = input()
a = 0
count = 0
b = 0
for i in range(0, len(s)):
	if s[i] == 'L':
		a = a - 1
	else:
		b = b + 1
for i in range(a, b + 1):
	count = count + 1
print(count)


n = int(input())
word = input()
countL = 0
countR = 0
for i in word:
	if i == 'L':
		countL += 1
	elif i == 'R':
		countR += 1
print(countL + countR + 1)


n = input()
c = input()
l = 0
r = 0
for i in c:
	if i == 'L':
		l += 1
	else:
		r += 1
print(r + l + 1)


import sys
import math
import heapq
import collections

def inputnum():
	return int(input())

def inputnums():
	return map(int, input().split())

def inputlist():
	return list(map(int, input().split()))

def inputstring():
	return [x for x in input()]

def inputstringnum():
	return [ord(x) - ord('a') for x in input()]

def inputmatrixchar(rows):
	arr2d = [[j for j in input().strip()] for i in range(rows)]
	return arr2d

def inputmatrixint(rows):
	arr2d = []
	for _ in range(rows):
		arr2d.append([int(i) for i in input().split()])
	return arr2d
n = inputnum()
s = inputstring()
l = s.count('L')
r = s.count('R')
print(l + r + 1)


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
from typing import List
N = int(input())
S = input()
left = len([v for v in S if v == 'L'])
right = len(S) - left
print(left + right + 1)


n = int(input())
s = str(input())
right = 0
left = 0
for i in s:
	if s == 'L':
		left += 1
	else:
		right += 1
print(right + left + 1)


n = int(input())
s = input()
LcoN = 0
RcoN = 0
for x in s:
	if s == 'L':
		LcoN += 1
	else:
		RcoN += 1
print(LcoN + RcoN + 1)


import re
n = int(input())
cmd = str(input())
print(len(re.findall('L', cmd)) + len(re.findall('R', cmd)) + 1)


n = input('')
s = input('')
l = 0
r = 0
for i in s:
	if i == 'L':
		l -= 1
	if i == 'R':
		r += 1
print(r - l + 1)


n = int(input())
cmds = input()
counts = {'L': 0, 'R': 0}
for c in cmds:
	counts[c] += 1
print(counts['L'] + counts['R'] + 1)


import sys
from collections import Counter
input = sys.stdin.readline

def main():
	_ = int(input())
	counter = Counter()
	commands = input()
	for command in commands:
		counter[command] += 1
	print(counter['L'] + counter['R'] + 1)
main()


def main():
	n = int(input())
	s = input()
	l = 0
	r = 0
	for x in s:
		if x == 'L':
			l -= 1
		else:
			r += 1
	print(r - l + 1)
main()


q = int(input())
string = input()
print(string.count('L') + string.count('R') + 1)


N = int(input())
S = input()
cl = S.count('L')
cr = S.count('R')
print(cr - -cl + 1)


a = int(input())
f = input()
print(a + 1)


n = int(input())
s = str(input())
print(s.count('L') + s.count('R') + 1)


n = int(input())
l = list(input())
a = l.count('L')
b = l.count('R')
count = a + b + 1
print(count)


from collections import Counter
n = int(input())
l = list(input())
x = Counter(l)
p = x['L']
q = x['R']
print(p + q + 1)


def main():
	n = int(input())
	string = input()
	print(n + 1)
main()


n = int(input())
a = input().strip()
l = 0
r = 0
for x in a:
	if x == 'L':
		l += 1
r = n - l
print(n + 1)


n = int(input())
string = list(input())
r = string.count('R')
l = string.count('L')
print(r + l + 1)


n = int(input())
s = str(input())
a = s.count('R')
b = s.count('L')
print(a + b + 1)


print(int(input()) + 1)
string = input()


n = input()
commands = input()
R_command = 0
L_command = 0
for letter in commands:
	if letter == 'R':
		R_command += 1
	else:
		L_command += 1
print(R_command + L_command + 1)


from collections import Counter
n = int(input())
s = input()
c = Counter(s)
print(c['L'] + c['R'] + 1)


n = int(input())
s = input()
c = 0
a = s.count('L')
b = s.count('R')
for i in range(-a, b + 1):
	c += 1
print(c)


a = int(input())
x = input()
print(a + 1)


INF = 10 ** 10

def main():
	n = get_int()
	st = list(input())
	print(st.count('L') + st.count('R') + 1)
import sys
out = []
get_int = lambda : int(input())
get_list = lambda : list(map(int, input().split()))
main()


N = int(input())
A = input()
L = A.count('L')
R = A.count('R')
ans = L + R + 1
print(ans)


n = int(input())
s = input()
c1 = s.count('L')
c2 = s.count('R')
ans = c2 + c1 + 1
print(ans)


n = int(input())
s = input()
(x, y) = (0, 0)
for i in range(n):
	if s[i] == 'L':
		x += 1
	else:
		y += 1
print(x + y + 1)


n = int(input())
com = input()
l = 0
r = 0
for c in com:
	if c == 'L':
		l += 1
	else:
		r += 1
ret = l + r + 1
print(ret)


n = int(input())
str1 = input()
L = R = 0
for i in range(len(str1)):
	if str1[i] == 'L':
		L = L + 1
	else:
		R = R + 1
print(L + R + 1)


n = int(input())
s = input()
ans = s.count('L') + s.count('R') + 1
print(ans)


n = int(input())
l = 0
r = 0
commands = input()
for letter in commands:
	if letter == 'L':
		l += 1
	else:
		r += 1
print(l + r + 1)


n = int(input())
b = input()
s = b[:n]
k = b.count('L')
l = b.count('R')
print(k + l + 1)


def answer():
	ans = int(input())
	input()
	return ans + 1
print(answer())


n = int(input())
s = list(input())
count_l = s.count('L')
count_r = s.count('R')
print(count_r + count_l + 1)


n = int(input())
s = input()
x = 0
l = s.count('L')
r = s.count('R')
print(l + r + 1)


n = int(input())
s = input()
L_count = 0
R_count = 0
for char in s:
	if char == 'L':
		L_count += 1
	if char == 'R':
		R_count += 1
print(L_count + R_count + 1)


n = int(input())
s = input()
l = s.count('L')
l = -l
r = s.count('R')
if l > r:
	print(l - r + 1)
else:
	print(r - l + 1)


inp = lambda : map(int, input().split())
n = int(input())
str = input()
print(str.count('L') + str.count('R') + 1)


n = int(input())
ch = input()
nbL = 0
nbR = 0
for i in ch:
	if i == 'L':
		nbL += 1
	else:
		nbR += 1
print(nbL + nbR + 1)


n = int(input())
stroka = str(input())
print(n + 1)


x = int(input())
l = input()
print(x + 1)


input()
c = input().count
print(c('L') + c('R') + 1)


n = int(input())
s = input()
ar = list(s)
x = ar.count('L')
print(n + 1)


n = int(input())
command = str(input())
arr_command = list(command)
L = arr_command.count('L')
R = arr_command.count('R')
print(R + L + 1)


n = int(input())
command = input()
commands = list(command)
print(commands.count('R') + commands.count('L') + 1)


def ab():
	b = int(input())
	q = list(input())
	w = q.count('L')
	e = q.count('R')
	print(w + e + 1)
ab()


x = int(input())
y = input()
c = 0
mc = y.count('R')
minc = -y.count('L')
for i in range(minc, mc + 1):
	c = c + 1
print(c)


n = int(input())
a = input()
a = list(a)
b = -a.count('L')
c = a.count('R')
print(c - b + 1)


from sys import stdin
r = stdin.readline

def main():
	n = int(r())
	comm = r().strip()
	left = right = 0
	for c in comm:
		if c == 'L':
			left += 1
		if c == 'R':
			right += 1
	print(left + right + 1)
main()


n = input()
d = input()
a = len(d)
c = a + 1
print(c)


from sys import stdin, stdout
import math, sys
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict
import bisect as bi
import heapq

def I():
	return int(input())

def In():
	return map(int, input().split())

def main():
	try:
		n = I()
		l = input().split()
		print(n + 1)
	except:
		pass
M = 998244353
P = 1000000007
main()


n = int(input())
s = input()
c_r = s.count('R')
c_l = s.count('L')
print(c_r + c_l + 1)


from sys import stdin
from collections import deque
from math import sqrt, floor, ceil, log, log2, log10, pi, gcd, sin, cos, asin

def ii():
	return int(stdin.readline())

def fi():
	return float(stdin.readline())

def mi():
	return map(int, stdin.readline().split())

def fmi():
	return map(float, stdin.readline().split())

def li():
	return list(mi())

def lsi():
	x = list(stdin.readline())
	x.pop()
	return x

def si():
	return stdin.readline()

def sieve(x):
	a = [True] * (x + 1)
	sq = floor(sqrt(x))
	for i in range(3, sq + 1, 2):
		if a[i]:
			for j in range(i * i, x + 1, i):
				a[j] = False
	if x > 1:
		p = [2]
	else:
		p = []
	for i in range(3, x + 1, 2):
		if a[i]:
			p.append(i)
	return p
n = ii()
a = si()
print(n + 1)


n = int(input())
s = input()
a = s.count('R')
b = s.count('L') * -1
ans = a - b + 1
print(ans)


n = input()
lis = list(input())
ans = lis.count('L') + lis.count('R')
print(ans + 1)


amount = int(input())
cmd = list(input())
left = 0
right = 0
for elem in cmd:
	if elem == 'L':
		left += 1
	else:
		right += 1
print(left + right + 1)


n = int(input())
s = input()
countl = 0
countr = 0
for i in s:
	if i == 'L':
		countl += 1
	else:
		countr += 1
left = 0 - countl
right = 0 + countr
print(countr + countl + 1)


import itertools

def int_str():
	return map(int, input().split())
_ = input()
s = input()
l = s.count('L')
r = s.count('R')
print(abs(l) + abs(r) + 1)


n = int(input())
s = str(input())
print(len(s) + 1)


x = input()
print(len(input()) + 1)


a = int(input())
string = input()
print(a + 1)


n = int(input())
m = str(input())
print(m.count('R') + m.count('L') + 1)


N = int(input())
S = input()
print(S.count('R') + S.count('L') + 1)


n = int(input())
str1 = input()
c1 = str1.count('L')
c2 = str1.count('R')
print(c1 + c2 + 1)


n = int(input())
s = input()
t1 = s.count('L')
t2 = s.count('R')
print(t1 + t2 + 1)


n = int(input())
s = list(input())
(L_count, R_count) = (0, 0)
for i in s:
	if i == 'L':
		L_count += 1
	else:
		R_count += 1
print(L_count + R_count + 1)


import sys, math
from collections import Counter, deque, defaultdict
from bisect import bisect_left, bisect_right
mod = 10 ** 9 + 7
INF = float('inf')

def inp():
	return int(sys.stdin.readline())

def inpl():
	return list(map(int, sys.stdin.readline().split()))
n = inp()
s = input()
print(n + 1)


n = int(input())
c = input()
nl = c.count('L')
nr = c.count('R')
print(nl + nr + 1)


n = int(input())
s = input()
cl = 0
cr = 0
for i in s:
	if i == 'L':
		cl += 1
	else:
		cr += 1
print(cl + cr + 1)


n = int(input())
s = input()
(c_l, c_r) = (s.count('L') * -1, s.count('R') * 1)
print(len(range(c_l, c_r + 1)))


n = input()
command = input()
l_command = command.count('L')
r_command = command.count('R')
ans = l_command + r_command + 1
print(ans)


t = int(input())
s = input()
x = s.count('L')
y = s.count('R')
print(x + y + 1)


def subs(s):
	return len(s) + 1
com = int(input())
s = input()
print(subs(s))


def Mezo(num, lst):
	left = 0
	right = 0
	for i in lst:
		if i == 'L':
			left += 1
		else:
			right += 1
	return left + right + 1

def main():
	n = eval(input())
	nums = input()
	nums = [i for i in nums]
	print(Mezo(n, nums))
main()


from sys import stdin, stdout
import bisect
import math

def st():
	return list(stdin.readline().strip())

def inp():
	return int(stdin.readline())

def li():
	return list(map(int, stdin.readline().split()))

def mp():
	return map(int, stdin.readline().split())

def pr(n):
	stdout.write(str(n) + '\n')

def soe(limit):
	l = [1] * (limit + 1)
	prime = []
	for i in range(2, limit + 1):
		if l[i]:
			for j in range(i * i, limit + 1, i):
				l[j] = 0
	for i in range(2, limit + 1):
		if l[i]:
			prime.append(i)
	return prime

def segsoe(low, high):
	limit = int(high ** 0.5) + 1
	prime = soe(limit)
	n = high - low + 1
	l = [0] * (n + 1)
	for i in range(len(prime)):
		lowlimit = low // prime[i] * prime[i]
		if lowlimit < low:
			lowlimit += prime[i]
		if lowlimit == prime[i]:
			lowlimit += prime[i]
		for j in range(lowlimit, high + 1, prime[i]):
			l[j - low] = 1
	for i in range(low, high + 1):
		if not l[i - low]:
			if i != 1:
				print(i)

def power(a, n):
	r = 1
	while n:
		if n & 1:
			r = r * a
			n = n - 1
		else:
			a = a * a
			n = n >> 1
	return r

def solve():
	n = inp()
	s = input()
	pr(n + 1)
for _ in range(1):
	solve()


n = int(input())
s = input()
l = []
for i in s:
	l.append(i)
k = 0
for j in range(0, len(l)):
	if l[j] == 'L':
		k = k + 1
s = 0
for j in range(0, len(l)):
	if l[j] == 'R':
		s = s + 1
print(k + s + 1)


t = int(input())
print(t + 1)


l = int(input())
commands = input()
print(l + 1)


x = int(input())
print(x + 1)


n = input()
st = input()
print(st.count('R') + st.count('L') + 1)


q = int(input())
w = input()
print(q + 1)


charNum = int(input())
string = input()
LNum = string.count('L')
RNum = string.count('R')
print(LNum + RNum + 1)


num = int(input())
lis = input()
print(num + 1)


n = int(input())
s = input()
num_l = 0
num_r = 0
for i in range(n):
	if s[i] == 'L':
		num_l += 1
	else:
		num_r += 1
print(num_l + num_r + 1)


n = int(input())
l = list(input())
print(l.count('L') + l.count('R') + 1)


n = int(input())
string = input()
print(string.count('L') + string.count('R') + 1)


n = int(input())
m = str(input())
m = list(m)
l = m.count('L')
r = m.count('R')
print(l + r + 1)


input()
s = input()
l = s.count('L')
r = len(s) - l
print(l + r + 1)


test = eval(input())
moves = input()
l = 0
r = 0
for i in moves:
	if i == 'L':
		l += 1
	else:
		r += 1
print(r + l + 1)


n = int(input())
s = input()
a = [ch for ch in s]
l = 0
r = 0
for i in a:
	if i == 'L':
		l += 1
	else:
		r += 1
result = l + r + 1
print(result)


n = int(input())
word = input()
print(word.count('R') + word.count('L') + 1)


n = int(input())
a = input()
b = [i == 'L' for i in a]
c = [i == 'R' for i in a]
l = sum(b)
r = sum(c)
print(l + r + 1)


n = int(input())
a = input()
l = a.count('L')
m = a.count('R')
print(l + m + 1)


input(int(input()) + 1)


n = int(input())
s = input()
c1 = s.count('L')
c2 = s.count('R')
a = -1 * c1
b = 1 * c2
print(b - a + 1)


a = int(input())
l = input()
print(l.count('R') + l.count('L') + 1)


(n, s) = (int(input()), input())
(cl, cr) = (s.count('L'), s.count('R'))
print(cl + cr + 1)


import os, sys
from io import BytesIO, IOBase

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())
import math
for i in range(1):
	n = ii()
	s = si()
	a = s.count('L')
	b = s.count('R')
	print(n + 1)


x = int(input())
cl = 0
cr = 0
str1 = str(input())
for i in range(0, x):
	if str1[i] == 'L':
		cl = cl + 1
	elif str1[i] == 'R':
		cr = cr + 1
print(cl + cr + 1)


n = input()
s = input()
pos = 0
pos += s.count('R')
pos += s.count('L')
if len(s) > 0:
	pos += 1
print(pos)


inn = int(input())
print(inn + 1)


n = int(input())
Lq = 0
Rq = 0
percuso = input()
for k in range(n):
	if percuso[k] == 'L':
		Lq += 1
	else:
		Rq += 1
print(1 + Lq + Rq)


n = int(input())
s = input()
left = 0
right = 0
for r in s:
	left += int(r == 'L')
	right += int(r == 'R')
print(f'{left + right + 1}')


n = int(input())
st = input()
d = {'L': 0, 'R': 0}
for i in range(n):
	d[st[i]] = d[st[i]] + 1
print(d['L'] + d['R'] + 1)


n = int(input())
string = input()
freq = [0, 0]
x = 0
for i in range(n):
	if string[i] == 'L':
		freq[0] += 1
		x -= 1
	else:
		freq[1] += 1
		x += 1
ans = 0
ans += freq[1] + freq[0] + 1
print(ans)


from sys import stdin

def main():
	input = lambda : stdin.readline()[:-1]
	N = int(input())
	S = input()
	l = S.count('L')
	r = S.count('R')
	print(l + r + 1)
main()


n = int(input())
ar = list(input())
x = ar.count('L')
y = ar.count('R')
print(x + y + 1)


n = int(input())
s = input()
x = s.count('L')
r = s.count('R')
print(x + r + 1)


from collections import Counter
n = int(input())
s = input()
mp = dict(Counter(s))
if 'L' not in mp.keys():
	print(mp['R'] + 1)
elif 'R' not in mp.keys():
	print(mp['L'] + 1)
else:
	print(mp['L'] + mp['R'] + 1)


def countL(a, b):
	r = 0
	for i in range(len(a)):
		if b in a:
			r += 1
	return r
n = int(input())
st = input()
st1 = st.replace('L', '')
st2 = st.replace('R', '')
print(countL(st2, 'L') + countL(st1, 'R') + 1)


n = int(input())
l = 0
r = 0
for i in input():
	if i == 'L':
		l -= 1
	elif i == 'R':
		r += 1
print(abs(l - r) + 1)


n = int(input())
t = input()
lc = 0
rc = 0
for c in t:
	if c == 'L':
		lc -= 1
	else:
		rc += 1
print(rc - lc + 1)


n = int(input())
cmds = input()
l = r = 0
for c in cmds:
	if c == 'L':
		l += 1
	else:
		r += 1
print(str(l + r + 1))


n = int(input())
t = input()
cntL = 0
cntR = 0
for i in range(n):
	if t[i] == 'L':
		cntL += 1
	elif t[i] == 'R':
		cntR += 1
print(cntL + cntR + 1)


n = int(input())
p = str(input())
q = 1 + len(p)
print(q)


x = int(input())
s = str(input())
ans = len(s) + 1
print(ans)


n = int(input())
s = input()
c1 = 0
c2 = 0
for i in s:
	if i == 'L':
		c1 += 1
	else:
		c2 += 1
print(c1 + c2 + 1)


input()
x = input()
z = x.count('R')
y = x.count('L')
print(z + y + 1)


x = int(input())
y = input()
a = y.count('L')
b = y.count('R')
print(a + b + 1)


n = int(input())
comands = input()
count_L = 0
count_R = 0
print(n + 1)


a = input()
b = input()
print(b.count('L') + b.count('R') + 1)


n = int(input())
s = input()
c = 0
for i in s:
	if i == 'R':
		c += 1
d = len(s) - c
print(c + d + 1)


a = int(input())
s = input()
poz = 1
l = 0
r = 0
for i in s:
	if i == 'L':
		r += 1
	else:
		l += 1
print(l + r + 1)


n = int(input())
string = input()
print(len(string) + 1)


from collections import defaultdict
a = defaultdict(int)
n = int(input())
s = input()
for i in s:
	if i == 'L':
		a[i] += 1
	else:
		a['R'] += 1
print(a['L'] + a['R'] + 1)


from sys import stdin
stdin.readline()
print(len(stdin.readline().rstrip()) + 1)


Number = int(input())
string = input()
print(Number + 1)


n = int(input())
s = list(input())
l = len(list(filter(lambda a: a == 'L', s)))
r = len(list(filter(lambda a: a == 'R', s)))
print(l + r + 1)


input()
path = input()
print(path.count('L') + path.count('R') + 1)


n = int(input())
s = input()
l_moves = s.count('L')
r_moves = len(s) - l_moves
print(l_moves + r_moves + 1)


import io
import os
from collections import Counter, defaultdict, deque

def solve(N, S):
	return S.count('R') + S.count('L') + 1
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
(N,) = [int(x) for x in input().split()]
S = input().decode().rstrip()
ans = solve(N, S)
print(ans)


t = int(input())
a = list(input())
left = a.count('L')
right = a.count('R')
total = left + right + 1
print(total)


n = int(input())
s = input()
r = s.count('L')
p = s.count('R')
print(p + r + 1)


n = int(input())
s = input()
countR = 0
countL = 0
count = 0
for i in s:
	if i == 'R':
		countR += 1
	else:
		countL += -1
for i in range(min(countL, countR), max(countL, countR) + 1):
	count += 1
print(count)


N = int(input())
Commands = input()
LeftN = 0
RightN = 0
for i in range(len(Commands)):
	if Commands[i] == 'R':
		Commands[i] == ''
LeftN = len(Commands)
RightN = N - LeftN
Total = LeftN + 1 + RightN
print(Total)


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush, nlargest, nsmallest
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from fractions import Fraction
mod = pow(10, 9) + 7
mod2 = 998244353

def data():
	return sys.stdin.readline().strip()

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
n = int(data())
s = data()
out(n + 1)


n = int(input())
s = input()
(max, min) = (0, 0)
max += s.count('R')
min -= s.count('L')
diff = max - min
print(diff + 1)


n = int(input())
commands = input()
rightMoves = commands.count('R')
leftMoves = -1 * commands.count('L')
print(len(range(leftMoves, rightMoves + 1)))


n = input()
s = input().strip()
print(s.count('L') + s.count('R') + 1)


x = int(input())
c = input()
countN = 0
countP = 0
for i in range(x):
	if c[i] == 'L':
		countN += 1
	elif c[i] == 'R':
		countP += 1
print(countN + countP + 1)


def solve(costs):
	costs = list(costs)
	l = costs.count('L')
	r = costs.count('R')
	print(l + r + 1)

def main():
	n = input()
	solve(input())
main()


n = int(input())
s = input()
c = 0
c1 = 0
for i in range(n):
	if s[i] == 'L':
		c = c + 1
	else:
		c1 = c1 + 1
print(c + c1 + 1)


n = int(input())
inp = input()
print(inp.count('L') + inp.count('R') + 1)


n = int(input())
s = input()
answer = 0
print(n + 1)


n = int(input())
s = input()
d = {'L': 0, 'R': 0}
for i in s:
	d[i] += 1
print(d['L'] + d['R'] + 1)


no = int(input())
moves = input()
print(no + 1)


import sys
input = sys.stdin.readline
n = int(input())
s = input()
max_ = 0
min_ = 0
pos = 0
for i in range(n):
	if s[i] == 'L':
		min_ -= 1
	else:
		max_ += 1
print(1 + max_ - min_)


n = int(input())
z = input()
z = list(z)
a = z.count('L')
b = z.count('R')
print(a + b + 1)


n = int(input())
inp = input()
l = inp.count('L')
r = inp.count('R')
print(l + r + 1)


exec('n = int(input()); s = str(input());print(n+1)')


n = int(input())
s = input()
l_count = s.count('L')
r_count = len(s) - l_count
ans = l_count + r_count + 1
print(ans)


n = int(input())
p = input()
leftmoves = p.count('L')
rightmoves = p.count('R')
print(leftmoves + rightmoves + 1)


a = int(input())
s = input()
b = s.count('L')
c = s.count('R')
d = b + c + 1
print(d)


n = int(input())
s = input()
a = s.count('L')
b = s.count('R')
res = b + a + 1
print(res)


import sys
n = int(input())
input2 = input()
print(n + 1)


def possible_locations(moves):
	return len(moves) + 1
useless = int(input())
movement = list(input())
print(useless + 1)


n = int(input())
s = str(input())
i = 0
numR = 0
numL = 0
if 1 <= n <= 10 ** 5:
	for i in range(0, len(s)):
		if 'R' in s:
			numR += 1
		elif 'L' in s:
			numL -= 1
print(numR + abs(numL) + 1)


n = eval(input())
s = input()
i = j = c = 0
while c < n:
	if s[c] == 'L':
		i += 1
	else:
		j -= 1
	c += 1
print(i - j + 1)


n = int(input())
s = input()
l = s.split('L')
r = s.split('R')
print(len(l) + len(r) - 1)


n = int(input())
p = input()
l = 0
r = 0
for i in range(len(p)):
	if p[i] == 'L':
		l = l - 1
	if p[i] == 'R':
		r = r + 1
s = r - l + 1
print(s)


from heapq import *
import math
from collections import defaultdict, Counter, deque
from bisect import *
import itertools
import fractions
MOD = 10 ** 9 + 7

def make_divisors(n):
	divisors = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			divisors.append(i)
			if i != n // i:
				divisors.append(n // i)
	divisors.sort()
	return divisors

def main():
	n = int(input())
	s = input()
	(l, r) = (0, 0)
	for i in range(n):
		if s[i] == 'R':
			r += 1
		else:
			l += 1
	print(r + l + 1)
main()


n = int(input())
s = input()
k = s.count('L')
p = s.count('R')
print(k + p + 1)


n = int(input())
ls = len(input())
if ls > n:
	print(n + 1)
else:
	print(ls + 1)


n = int(input())
comands = input()
ans = 1
ans += comands.count('L')
ans += comands.count('R')
print(ans)


n = int(input())
st = input()
l = []
l.extend(st)
print(1 + l.count('L') + l.count('R'))


n = int(input())
S = input()
l = S.count('L')
r = S.count('R')
print(r + l + 1)


num = int(input())
commands = str(input())
x = 0
lst = [0]
for i in commands:
	if i == 'L':
		x -= 1
		lst.append(x)
	else:
		x += 1
		lst.append(x)
print(len(lst))


n = int(input())
s = input()
nL = s.count('L')
nR = s.count('R')
print(nL + nR + 1)


n = int(input())
s = list(input())
print(s.count('R') + s.count('L') + 1)


mod = 10 ** 9 + 7
import math
from itertools import combinations

def ain():
	return map(int, input().split())

def fain():
	return map(float, input().split())
n = int(input())
s = input()
print(s.count('L') + s.count('R') + 1)


n = int(input())
c = input()
neg = c.count('L')
pos = c.count('R')
print(neg + pos + 1)


t = int(input())
s = input()
l = list(s)
lc = l.count('L')
uc = l.count('R')
c = 0
for i in range(-lc, uc + 1):
	c = c + 1
print(c)


n = int(input())
g = input()
print(n + 1)


n = int(input())
commands = input()
ans = n + 1
print(ans)


n = int(input())
l = input()
print(n + 1)


import sys
import collections
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s)])

def invr():
	return map(int, input().split())

def do():
	n = inp()
	s = insr()
	ct = collections.Counter(s)
	l = ct['L']
	r = ct['R']
	return l + r + 1
ans = do()
print(ans)


n = int(input())
s = list(input())
d = s.count('L')
k = s.count('R')
print(d + k + 1)


import sys
len = int(input())
positions = str(input())
print(len + 1)


n = int(input())
s = input()
x = s.count('R')
y = s.count('L')
print(x + y + 1)


n = input()
s = input()
L = 0
R = 0
for i in s:
	if i == 'L':
		L += 1
	else:
		R += 1
print(L + R + 1)


_ = int(input())
s = input()
print(s.count('L') + s.count('R') + 1)


t = int(input())
s = input()
l = list(s)
c1 = l.count('R')
c2 = l.count('L')
print(c1 + c2 + 1)


a = input()
a = input()
print(1 + len(a))


input()
inp = input()
print(inp.count('L') + inp.count('R') + 1)


a = int(input())
x = input()
l = x.count('L')
r = x.count('R')
print(l + r + 1)


n = int(input())
commands = input()
left = 0
right = 0
for command in commands:
	if command == 'L':
		left += 1
	elif command == 'R':
		right += 1
print(left + right + 1)


print(str(int(input()) + 1))


x = int(input())
p = input('')
print(x + 1)


n = int(input())
inputs = input()
max_left = inputs.count('L')
max_right = inputs.count('R')
res = abs(-max_left - max_right) + 1
print(res)


n = input()
l = input()
c1 = c2 = 0
for i in l:
	if i == 'L':
		c1 += 1
	else:
		c2 += 1
print(c1 + c2 + 1)


t = int(input())
s = str(input())
sum = 0
count = 0
for i in range(0, len(s), 1):
	if s[i] == 'L':
		count += 1
	if s[i] == 'R':
		sum += 1
print(sum + count + 1)


n = int(input())
s = input()
l = []
c = 0
d = 0
for i in range(n):
	l.append(s[i])
for i in range(n):
	if l[i] is 'L':
		c = c + 1
	else:
		d = d + 1
print(c + d + 1)


import math
import os
import random
import re
import sys
m = int(input())
s = str(input())
print(s.count('L') + s.count('R') + 1)


a = input()
b = input()
l = r = 0
for io in b:
	if io == 'L':
		l += 1
	else:
		r += 1
print(l + r + 1)


a = int(input())
b = input()
x = 0
for e in range(0, len(b)):
	if b[e] == 'L':
		x += 1
	if b[e] == 'R':
		x += 1
print(x + 1)


a = int(input())
b = input()
L = b.count('L')
R = b.count('R')
c = L + R
print(c + 1)


a = int(input())
b = input()
print(str(a + 1))


n = int(input())
x = input()
print(x.count('L') + x.count('R') + 1)


t = int(input())
s = input()
f = s.count('L')
r = s.count('R')
print(f + r + 1)


import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log2, ceil
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
from bisect import insort
from collections import Counter
from collections import deque
from heapq import heappush, heappop, heapify
from itertools import permutations, combinations
mod = int(1000000000.0) + 7
ip = lambda : int(stdin.readline())
inp = lambda : map(int, stdin.readline().split())
ips = lambda : stdin.readline().rstrip()
out = lambda x: stdout.write(str(x) + '\n')
t = 1
for _ in range(t):
	n = ip()
	s = ips()
	neg = s.count('L')
	pos = s.count('R')
	ans = neg + pos + 1
	out(ans)


n = int(input())
str = input()
x = str.count('L')
y = str.count('R')
print(x + y + 1)


n = int(input())
orders = input()
lefts = 0
rights = 0
for order in orders:
	if order == 'L':
		lefts += 1
	else:
		rights += 1
print(lefts + rights + 1)


num = int(input())
command = list(input())
count_L = 0
count_R = 0
for com in command:
	if com == 'L':
		count_L += 1
	else:
		count_R += 1
print(count_L + count_R + 1)


int(input())
s = input()
print(len(range(s.count('L') * -1, s.count('R'))) + 1)


t = int(input())
a = input()
print(t + 1)


n = int(input())
s = input()
lc = 0
rc = 0
for i in range(n):
	if s[i] == 'L':
		lc += 1
	else:
		rc += 1
print(lc + rc + 1)


N = int(input())
print(N + 1)


import re
n = int(input())
x = input()
a = len(re.findall('L', x))
b = len(re.findall('R', x))
print(a + b + 1)


n = int(input())
s = list(input())
l = s.count('L')
r = s.count('R')
print(l + r + 1)


q = int(input())
moves = [q]
moves = list(input())
print(q + 1)


n = int(input())
count_ = 1
string_ = str(input())
count = n
while n > 0:
	for i in string_:
		if i == 'L':
			count = count - 1
			count_ = count_ + 1
			n = n - 1
		elif i == 'R':
			count = count + 1
			count_ = count_ + 1
			n = n - 1
print(count_)


n = int(input())
cmd = input()
print(cmd.count('L') + cmd.count('R') + 1)


n = int(input())
s = input()
l = [c for c in s]
min = -1 * l.count('L')
max = l.count('R')
count = 0
for i in range(min, max + 1):
	count += 1
print(count)


import sys

def input():
	return sys.stdin.readline().strip()

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
N = INT()
S = input()
lcnt = S.count('L')
rcnt = S.count('R')
ans = 1 + lcnt + rcnt
print(ans)


def intinputlist():
	l = [int(x) for x in input().split()]
	return l

def printlist(l):
	print(*l)

def power(x, y, p):
	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
n = int(input())
comm = list(input())
l = comm.count('L')
r = comm.count('R')
print(l + r + 1)


t = int(input())
x = list(input()[:t])
if t == 0:
	print(0)
else:
	print(t + 1)


def main():
	n = int(input())
	c = input()
	print(n + 1)
main()


print(int(input()) + 1)


import math, itertools, fractions, heapq, collections, bisect, sys, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def LS():
	return sys.stdin.readline().split()

def S():
	return input()

def main():
	n = I()
	s = S()
	x = y = 0
	for a in s:
		if a == 'L':
			x += 1
		else:
			y += 1
	return x + y + 1
print(main())


n = int(input())
commands = input()
print(len(commands) + 1)


n = int(input())
s = input()
l = 0
r = 0
for c in s:
	if c == 'L':
		l += 1
	else:
		r += 1
print(l + r + 1)


n = int(input())
s = str(input())
d = s.count('L')
e = s.count('R')
sum = d + e + 1
print(sum)


lixo = input()
string = input()
lista_s = list(string)
(cnt_r, cnt_l) = (0, 0)
for i in lista_s:
	if i == 'R':
		cnt_r += 1
	else:
		cnt_l += 1
print(cnt_r + cnt_l + 1)


t = int(input())
s = input()
print(t + 1)


input()
print(len(input()) + 1)


S = int(input())
n = input()
l = n.count('L')
r = n.count('R')
print(abs(0 - l) + (r + 1))


import sys
t = int(input())
s = input()
l = s.count('L')
L = l * -1
r = s.count('R')
print(r - L + 1)


from sys import *
input = stdin.readline
n = int(input())
s = input()
print(n + 1)


n = int(input())
l = input()
count_of_l = 0
count_of_r = 0
print(n + 1)


n = int(input())
forget = input()
print(n + 1)


def func(str_):
	print(len(str_) + 1)
n = int(input())
str_ = input()
func(str_)


n = int(input())
p = input()
(count_l, count_r) = (0, 0)
for i in range(len(p)):
	if p[i] == 'L':
		count_l += 1
	else:
		count_r += 1
print(count_r + count_l + 1)


n = int(input())
line = input()
r = line.count('R')
l = line.count('L')
print(r + l + 1)


n = input()
s = input()
m = 0
ma = 0
for i in s:
	if i == 'L':
		m -= 1
	else:
		ma += 1
print(ma - m + 1)


n = int(input())
s = input()
l = r = 0
for ch in s:
	if ch == 'L':
		l -= 1
	else:
		r += 1
print(f'{r - l + 1}')


n = input()
trash = input()
n = int(n)
print(n + 1)


(n, com) = (int(input()), input())
print(com.count('L') + com.count('R') + 1)


t = int(input())
s = input()
print(s.count('L') + s.count('R') + 1)


n = int(input())
s = input()
L = s.count('L')
R = s.count('R')
tot = L + R + 1
print(tot)


from collections import Counter
N = int(input())
arr = Counter(input())
ans = 0
for (key, value) in arr.items():
	ans += value
print(ans + 1)


def solve(n, s):
	return s.count('R') + s.count('L') + 1

def main():
	n = int(input())
	s = input()
	print(solve(n, s))
main()


n = int(input())
s = input()
b = list(s)
l = 0
r = 0
for i in b:
	if i == 'L':
		l += 1
	else:
		r += 1
print(l + r + 1)


n = int(input())
s = input()
countl = s.count('L')
countr = s.count('R')
print(countl + countr + 1)


n = int(input())
dict = {'L': 0, 'R': 1}
amounts = [0, 0]
for char in input():
	amounts[dict[char]] += 1
print(sum(amounts) + 1)


n = int(input())
s = input()
dic = {'L': 0, 'R': 0}
for x in range(0, n):
	if s[x] == 'R':
		dic['R'] = dic['R'] + 1
	else:
		dic['L'] = dic['L'] + 1
ans = int(dic['L']) + int(dic['R']) + 1
print(ans)


n = int(input())
s = [i for i in input().split()]
print(n + 1)


n = input()
arr = input()
l = 0
r = 0
for i in arr:
	if i == 'L':
		l += 1
	elif i == 'R':
		r += 1
print(r + l + 1)


x = int(input())
y = input()
print(len(y) + 1)


import sys
from sys import stdin, stdout
import bisect
import math
import heapq

def modinv(n, p):
	return pow(n, p - 2, p)

def cin():
	return map(int, sin().split())

def ain():
	return list(map(int, sin().split()))

def sin():
	return input()

def inin():
	return int(input())
import math

def Divisors(n):
	l = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
	return l

def modInverse(b, m):
	g = math.gcd(b, m)
	if g != 1:
		return -1
	else:
		return pow(b, m - 2, m)

def modDivide(a, b, m):
	a = a % m
	inv = modInverse(b, m)
	if inv == -1:
		print('Division not defined')
	else:
		return inv * a % m

def main():
	n = inin()
	s = sin()
	print(n + 1)
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s: self.buffer.write(s.encode('ascii'))
			self.read = lambda : self.buffer.read().decode('ascii')
			self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
import sys

class ostream:

	def __lshift__(self, a):
		sys.stdout.write(str(a))
		return self
cout = ostream()
endl = '\n'

def readnumbers(zero=0):
	conv = ord if py2 else lambda x: x
	A = []
	numb = zero
	sign = 1
	i = 0
	s = sys.stdin.buffer.read()
	try:
		while True:
			if s[i] >= b'0'[0]:
				numb = 10 * numb + conv(s[i]) - 48
			elif s[i] == b'-'[0]:
				sign = -1
			elif s[i] != b'\r'[0]:
				A.append(sign * numb)
				numb = zero
				sign = 1
			i += 1
	except:
		pass
	if s and s[-1] >= b'0'[0]:
		A.append(sign * numb)
	return A
main()


n = int(input())
s = input()
ans = 0
lr = {'L': 0, 'R': 0}
for i in range(n):
	lr[s[i]] += 1
ans = lr['L'] + lr['R'] + 1
print(ans)


n = int(input())
s = input()
(iz, der) = (0, 0)
for i in range(n):
	if s[i] == 'L':
		iz -= 1
	else:
		der += 1
print(der - iz + 1)


n = int(input())
s = input()
a = 0
for i in s:
	if i == 'L':
		a += 1
b = n - a
print(a + b + 1)


length = int(input())
command = input()
pos = 0
neg = 0
for i in range(length):
	if command[i] == 'L':
		pos += 1
	else:
		neg += 1
print(pos + neg + 1)


n = int(input())
t = input()
print(n + 1)


n = int(input())
commands = input()
lefts = commands.count('L')
rights = commands.count('R')
print(lefts + rights + 1)


n = int(input())
commands = input()
posL = 0
posR = 0
for command in commands:
	if command == 'L':
		posL -= 1
	else:
		posR += 1
ans = abs(posL - posR) + 1
print(ans)


import sys
input = sys.stdin.readline
n = int(input())
s = input()
print(s.count('R') + s.count('L') + 1)


from sys import stdin
n = int(stdin.readline().strip())
a = stdin.readline().strip()
l = a.count('L')
r = a.count('R')
print(l + r + 1)


tc = int(input())
arr = input()
left = arr.count('L')
right = arr.count('R')
print(left + right + 1)


from __future__ import division, print_function
import os, sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().strip().split(' '))

def msi():
	return map(str, input().strip().split(' '))

def li():
	return list(mi())

def dmain():
	sys.setrecursionlimit(100000000)
	threading.stack_size(40960000)
	thread = threading.Thread(target=main)
	thread.start()
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def getKey(item):
	return item[1]

def sort2(l):
	return sorted(l, key=getKey, reverse=True)

def d2(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def ntl(n):
	return [int(i) for i in str(n)]

def powerMod(x, y, p):
	res = 1
	x %= p
	while y > 0:
		if y & 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def read():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def main():
	n = ii()
	s = si()
	l = s.count('L')
	r = s.count('R')
	print(l + r + 1)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


from math import ceil
from math import factorial
from collections import *
from operator import itemgetter
ii = lambda : int(input())
iia = lambda : list(map(int, input().split()))
isa = lambda : list(input().split())
x = ii()
s = input()
L = s.count('L')
R = s.count('R')
print(L + R + 1)


n = int(input())
a = input()
l = 0
r = 0
for x in a:
	if x == 'L':
		l = l + 1
	else:
		r = r + 1
ans = 1 + l + r
print(ans)


n = int(input())
s = str(input())
l = 0
r = 0
for i in s:
	if i == 'L':
		l += 1
	else:
		r += 1
ans = l + r + 1
print(ans)


def solve(n, s):
	if len(s) != n:
		return -1
	else:
		return len(s) + 1

def main():
	n = int(input())
	s = input()
	print(solve(n, s))
main()


def func(st):
	l = st.count('L')
	r = st.count('R')
	return l + r + 1
n = int(input())
st = input()
print(func(st))


n = int(input())
k = input()
print(n + 1)


i = int(input())
j = input()
print(i + 1)


def solve(s):
	numL = s.count('L')
	numR = s.count('R')
	print(numL + numR + 1)

def main():
	n = input()
	s = input()
	solve(s)
main()


t = int(input())
str = input()
print(t + 1)


d = int(input())
input()
print(d + 1)


n = int(input())
arr = str(input())
l = 0
r = 0
for i in range(n):
	if arr[i] == 'L':
		l -= 1
	else:
		r += 1
print(abs(r - l) + 1)


nada = input()
string = input()
l = 'L'
r = 'R'
l = string.count(l)
r = string.count(r)
print(l + r + 1)


n = int(input())
strr = input()
l = strr.count('L')
r = strr.count('R')
print(l + r + 1)


x = int(input())
y = input()
count = 0
for i in range(len(y)):
	count += 1
print(count + 1)


n = int(input())
st1 = input()
l = 0
r = 0
for i in range(n):
	if st1[i] == 'L':
		l += 1
	if st1[i] == 'R':
		r += 1
print(l + r + 1)


n = int(input())
s = input()
c = 0
k = 0
for x in s:
	if x == 'L':
		k -= 1
	else:
		c += 1
print(c - k + 1)


no = int(input())
moves = input()
(x, y) = (0, 0)
for i in moves:
	if i == 'L':
		x += 1
	elif i == 'R':
		y += 1
print(x + y + 1)


n = int(input())
s = input()
l = list(s)
c = l.count('L')
c1 = l.count('R')
print(c + c1 + 1)


import io, sys, atexit, os
import math as ma
from sys import exit
from decimal import Decimal as dec
from itertools import permutations
from itertools import combinations

def li():
	return list(map(int, sys.stdin.readline().split()))

def num():
	return map(int, sys.stdin.readline().split())

def nu():
	return int(input())

def find_gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def lcm(x, y):
	gg = find_gcd(x, y)
	return x * y // gg
mm = 1000000007

def solve():
	t = 1
	for tt in range(t):
		n = nu()
		s = input()
		l = s.count('L')
		r = s.count('R')
		print(l + r + 1)
solve()


def main():
	n = int(input())
	c = input()
	l = c.count('L')
	r = c.count('R')
	print(l + r + 1)
main()


def solve():
	n = int(input())
	stri = input()
	return n + 1
ans = solve()
print(ans)


n = int(input())
s = input()
if len(s) == n:
	l = s.count('L')
	n = s.count('R')
	print(l + n + 1)


n = int(input())
s = input()
neg = s.count('L')
pos = s.count('R')
print(neg + pos + 1)


x = int(input())
s = input()
b = 0
a = 0
for i in range(len(s)):
	if i == 'L':
		a = a + 1
	else:
		b = b + 1
print(a + b + 1)


def solve():
	nn = int(input())
	lr = [i for i in input()]
	l = -1 * lr.count('L')
	r = lr.count('R')
	print(r - l + 1)
solve()


def m(a):
	a = list(a)
	p = a.count('L')
	q = a.count('R')
	return p + q + 1
n = int(input())
a = input()
print(m(a))


n = int(input())
string = str(input())
print(n + 1)


n = int(input())
s = list(input())
s.sort()
num_l = 0
num_r = 0
if s[0] == s[-1] == 'L':
	num_l = n
elif s[0] == s[-1] == 'R':
	num_r = n
else:
	for i in range(n - 1):
		if s[i] != s[i + 1]:
			num_l = i + 1
			num_r = n - (i + 1)
print(num_r + num_l + 1)


t = int(input())
n = input()
c1 = 0
c2 = 0
for i in range(t):
	if n[i] == 'L':
		c1 += 1
	else:
		c2 += 1
print(c2 + c1 + 1)


t = int(input())
s = str(input())
l = len(s)
sum = 0
for i in range(0, l, 1):
	if s[i] == 'L':
		sum = sum - 1
	else:
		sum = sum + 1
print(t + 1)


n = input()
s = input()
print(len(s) + 1)


n = int(input())
s = str(input())
l = list(s)
k = l.count('L')
print(k + n - k + 1)


try:
	n = int(input())
	s = input()
	c = 0
	d = 0
	for i in s:
		if i == 'L':
			c += 1
		else:
			d += 1
	print(c + d + 1)
except:
	pass


a = int(input())
b = input()
g = b.count('L')
h = b.count('R')
print(g + h + 1)


import sys, math
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return s[:len(s) - 1]

def invr():
	return map(int, input().split())
t = 1
for tt in range(t):
	n = inp()
	a = insr()
	print(len(a) + 1)


def solve():
	n = input()
	s = input()
	l = s.count('L')
	r = s.count('R')
	print(l + r + 1)
solve()


num_commands = int(input())
commands = str(input())
aux1 = 0
aux2 = 0
x = 0
for i in range(len(commands)):
	if commands[i] == 'L':
		x -= 1
	else:
		x += 1
num_commands += 1
print(num_commands)


k = input()
a = list(map(str, input().strip().split()))
c = 0
k = 0
for i in a:
	for j in i:
		if j == 'L':
			c -= 1
		if j == 'R':
			k += 1
print(k - c + 1)


from sys import stdin, stdout
import gc
from copy import deepcopy
from itertools import permutations
gc.disable()
input = stdin.readline
import math

def power(x, y, p):
	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
n = int(input().strip())
string = input().strip()
l = 0
r = 0
for i in string:
	if i == 'L':
		l += 1
	else:
		r += 1
print(l + r + 1)


(l, r) = (0, 0)
x = int(input())
arr = [ch for ch in input()]
for i in arr:
	if i == 'L':
		l += 1
	else:
		r += 1
print(l + r + 1)


a = input()
b = input()
lst = b.split(' ')
count1 = 0
count2 = 0
for i in lst:
	if i == 'L':
		count1 = count1 - 1
	if i == 'R':
		count2 += 1
	if count2 + count1 == 0:
		print(count2 - count1 + 1 + int(a))
	else:
		print(count2 - count1 + int(a))


p = int(input())
lr = input()
print(len(lr) + 1)


MAX = 1 << 20
while True:
	try:
		n = eval(input())
		str0 = input()
		print(n + 1)
	except:
		break


from sys import stdin, stdout, setrecursionlimit
from math import ceil
n = int(input())
s = input()
cntl = cntr = 0
for x in s:
	if x == 'L':
		cntl += 1
	else:
		cntr += 1
print(cntl + cntr + 1)


n = int(input())
s = input()
x_max = 0
x_min = 0
for item in s:
	if item == 'L':
		x_min -= 1
	if item == 'R':
		x_max += 1
print(x_max - x_min + 1)


n = int(input())
s = input()
a = list(s)
c = a.count('L') + a.count('R') + 1
print(c)


def main():
	n = int(input())
	commands = input()
	x = 0
	y = 0
	for each in commands:
		if each == 'L':
			x += 1
		else:
			y += 1
	print(x + y + 1)
main()


n = input()
n = int(n)
a = input()
count_l = 0
count_r = 0
for item in a:
	if item == 'L':
		count_l += 1
	else:
		count_r += 1
print(count_l + count_r + 1)


def main():
	print(int(input()) + 1)
main()


n = int(input())
if n <= 100000 and n >= 1:
	s = input()
	print(n + 1)


int(input())
commands = input()
left = right = 0
for i in commands:
	if i == 'L':
		left += 1
	else:
		right += 1
print(left + right + 1)


number = int(input())
first = input()
r = first.count('R')
l = number - r
cnt = 0
for i in range(-l, r + 1):
	cnt += 1
print(cnt)


n = int(input())
s = input()
l = s.count('L')
r = s.count('R')
c = l + r + 1
print(c)


n = int(input())
test = input()
print(test.count('L') + test.count('R') + 1)


from bisect import bisect_left as bl
from bisect import bisect_right as br
import heapq
import math
from collections import *
from functools import reduce, cmp_to_key
import sys
input = sys.stdin.readline
M = mod = 998244353

def factors(n):
	return sorted(list(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))))

def li():
	return [int(i) for i in input().rstrip('\n').split()]

def st():
	return input().rstrip('\n')

def val():
	return int(input().rstrip('\n'))

def li2():
	return [i for i in input().rstrip('\n').split(' ')]

def li3():
	return [int(i) for i in input().rstrip('\n')]
n = val()
s = Counter(st())
print(s['L'] + s['R'] + 1)


n = int(input())
s = input().upper()
l = s.count('L')
r = s.count('R')
x = 0 - l
y = 0 + r
count = 0
for i in range(x, y + 1):
	count += 1
print(count)


n = input()
s = str(input())
tam = len(s)
ls = 0
for i in s.split():
	if i == 'L':
		ls += 1
rs = tam - ls
print(rs + ls + 1)


t = int(input())
a = input()
print(a.count('L') + a.count('R') + 1)


n = int(input())
s = input()
Lcount = 0
Rcount = 0
for i in s:
	if i == 'L':
		Lcount += 1
	else:
		Rcount += 1
print(Lcount + Rcount + 1)


input()
s = input()
l = sum((1 for x in s if x == 'L'))
r = sum((1 for x in s if x == 'R'))
print(l + r + 1)


import sys
length = int(sys.stdin.readline())
commands = sys.stdin.readline()
print(length + 1)


n = int(input())
a1 = 0
a2 = 0
a = input()
for i in range(n):
	if a[i] == 'L':
		a1 += 1
	else:
		a2 += 1
print(a1 + 1 + a2)


n = int(input())
s = input()
right = s.count('R')
left = s.count('L')
if right == 0:
	print(left + 1)
elif left == 0:
	print(right + 1)
else:
	print(right + left + 1)


n = int(input())
arr = input()
l_idx = -arr.count('L')
r_idx = arr.count('R')
cnt = 0
for i in range(l_idx, r_idx + 1):
	cnt += 1
print(cnt)


n = input()
s = list(input())
lefts = s.count('L')
rights = s.count('R')
print(lefts + rights + 1)


import sys
import math
import itertools
import functools
import collections
import operator

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def wr(arr):
	return ' '.join(map(str, arr))

def revn(n):
	return str(n)[::-1]

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)

def sieve(n):
	if n < 2:
		return list()
	prime = [True for _ in range(n + 1)]
	p = 3
	while p * p <= n:
		if prime[p]:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 2
	r = [2]
	for p in range(3, n + 1, 2):
		if prime[p]:
			r.append(p)
	return r

def divs(n, start=1):
	r = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				r.append(i)
			else:
				r.extend([i, n // i])
	return r

def divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True

def convn(number, base):
	newnumber = 0
	while number > 0:
		newnumber += number % base
		number //= base
	return newnumber

def cdiv(n, k):
	return n // k + (n % k != 0)
n = ii()
s = input()
print(n + 1)


n = int(input())
l = list(str(input()))
print(n + 1)


from functools import reduce
n = int(input())
commands = list(input())
left_edge = 0
right_edge = 0
for c in commands:
	if c == 'L':
		left_edge = left_edge + 1
	else:
		right_edge = right_edge + 1
print(left_edge + right_edge + 1)


input()
l = input()
print(l.count('L') + 1 + l.count('R'))


a = int(input())
s = input()
r = s.count('R')
l = s.count('L')
result = r + l + 1
print(result)


from math import *
from sys import stdin, stdout
import itertools, os, sys, threading
from collections import deque, Counter, OrderedDict, defaultdict
from heapq import *
from fractions import Fraction
mod = 100000009

def ii():
	return int(input())

def si():
	return str(input())

def mi():
	return map(int, input().split())

def li():
	return list(mi())

def fii():
	return int(stdin.readline())

def fsi():
	return str(stdin.readline())

def fmi():
	return map(int, stdin.readline().split())

def fli():
	return list(fmi())
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}

def getKey(item):
	return item[0]

def sort2(l):
	return sorted(l, key=getKey)

def d2(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def ntl(n):
	return [int(i) for i in str(n)]

def powerMod(x, y, p):
	res = 1
	x %= p
	while y > 0:
		if y & 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000

def bfs(d, v):
	q = []
	q.append(v)
	visited[v] = 1
	while len(q) != 0:
		x = q[0]
		q.pop(0)
		for i in d[x]:
			if visited[i] != 1:
				visited[i] = 1
				q.append(i)
		print(x)

def make_graph(e):
	d = {}
	for i in range(e):
		(x, y) = mi()
		if x not in d:
			d[x] = [y]
		else:
			d[x].append(y)
		if y not in d:
			d[y] = [x]
		else:
			d[y].append(x)
	return d

def gr2(n):
	d = defaultdict(list)
	for i in range(n):
		(x, y) = mi()
		d[x].append(y)
	return d

def connected_components(graph):
	seen = set()

	def dfs(v):
		vs = set([v])
		component = []
		while vs:
			v = vs.pop()
			seen.add(v)
			vs |= set(graph[v]) - seen
			component.append(v)
		return component
	ans = []
	for v in graph:
		if v not in seen:
			d = dfs(v)
			ans.append(d)
	return ans

def primeFactors(n):
	s = set()
	while n % 2 == 0:
		s.add(2)
		n = n // 2
	for i in range(3, int(sqrt(n)) + 1, 2):
		while n % i == 0:
			s.add(i)
			n = n // i
	if n > 2:
		s.add(n)
	return s

def find_all(a_str, sub):
	start = 0
	while True:
		start = a_str.find(sub, start)
		if start == -1:
			return
		yield start
		start += len(sub)

def SieveOfEratosthenes(n, isPrime):
	isPrime[0] = isPrime[1] = False
	for i in range(2, n):
		isPrime[i] = True
	p = 2
	while p * p <= n:
		if isPrime[p] == True:
			i = p * p
			while i <= n:
				isPrime[i] = False
				i += p
		p += 1
	return isPrime

def dijkstra(edges, f, t):
	g = defaultdict(list)
	for (l, r, c) in edges:
		g[l].append((c, r))
	(q, seen, mins) = ([(0, f, ())], set(), {f: 0})
	while q:
		(cost, v1, path) = heappop(q)
		if v1 not in seen:
			seen.add(v1)
			path = (v1, path)
			if v1 == t:
				return (cost, path)
			for (c, v2) in g.get(v1, ()):
				if v2 in seen:
					continue
				prev = mins.get(v2, None)
				next = cost + c
				if prev is None or next < prev:
					mins[v2] = next
					heappush(q, (next, v2, path))
	return float('inf')
n = ii()
s = si()
(l, r) = (0, 0)
for i in range(n):
	if s[i] == 'L':
		l += 1
	if s[i] == 'R':
		r += 1
print(l + r + 1)


n_command = int(input())
commands = list(input())
n_pos = commands.count('L')
p_pos = commands.count('R')
print(n_pos + p_pos + 1)


n = int(input())
cont = input()
a = cont.count('L')
b = cont.count('R')
print(a + b + 1)


import sys
n = int(input())
commands = input()
l = commands.count('L')
r = n - l
print(l + r + 1)


x = 0
a = int(input())
b = list(input())
l = b.count('L')
r = b.count('R')
print(l + r + 1)


n = int(input())
l = input().count('L')
r = n - l
del n
print(r + l + 1)


n = int(input())
s = input()
(pol, neg) = (0, 0)
for item in s:
	if item == 'R':
		pol += 1
	else:
		neg += 1
print(pol + neg + 1)


n = int(input())
comand = input()
print(comand.count('L') + comand.count('R') + 1)


n = int(input())
aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = input()
print(n + 1)


x = int(input())
y = input()
nol = 1
nor = 0
for i in range(x):
	if y[i] == 'L':
		nol = nol + 1
	elif y[i] == 'R':
		nor = nor + 1
print(nol + nor)


n = int(input())
command = input()
print(len(command) + 1)


x = int(input())
s = input()
print(x + 1)


def num():
	return int(input())

def line():
	return map(int, input().split())
from itertools import repeat
n = num()
s = input()
print(1 + len(s))


s = input()
a = list(input())
x = a.count('R')
y = a.count('L')
print(abs(x) + abs(y) + 1)


n = int(input())
s = input()
(m, count, count1) = ([], 0, 0)
for i in range(len(s)):
	if s[i] == 'L':
		count -= 1
	elif s[i] == 'R':
		count1 += 1
i = 1
while 1:
	count += 1
	i += 1
	if count == count1:
		break
print(i)


while True:
	x = int(input(''))
	if 0 < x:
		break
s = 0
k = 0
while True:
	y = input('')
	if len(y) == x:
		s += 1
	z = y.upper()
	if z == y:
		s += 1
	for i in y:
		if i == 'R' or i == 'L':
			k += 1
	if k == len(y):
		s += 1
	if s == 3:
		break
print(x + 1)


x = int(input())
string1 = input()
print(x + 1)


x = int(input())
n = input()
a = n.count('L')
b = n.count('R')
print(b + a + 1)


c = 0
c1 = 0
l = []
n = int(input())
s = str(input())
for i in s:
	if i == 'L':
		c -= 1
	else:
		c1 += 1
print(abs(c1 - c) + 1)


n = int(input())
q = input()
q = sorted(q)
l = q.count('L')
r = n - l
print(l + r + 1)


n = int(input())
c = input()
l = 0
r = 0
for i in range(len(c)):
	if c[i] == 'L':
		l += 1
	elif c[i] == 'R':
		r += 1
print(l + r + 1)


n = int(input())
s = input()
(q1, q2) = (0, 0)
for i in range(n):
	if s[i] == 'L':
		q1 -= 1
	else:
		q2 += 1
print(q2 - q1 + 1)


n = int(input())
l = list(input())
l1 = l.count('L')
r1 = l.count('R')
print(l1 + r1 + 1)


import re
n = input()
moves = input()
l = re.findall('L', moves)
r = re.findall('R', moves)
print(1 + len(l) + len(r))


n = int(input())
stroka = list(input())
L = stroka.count('L')
R = stroka.count('R')
print(L + R + 1)


class Solution:

	def solve(self, commands):
		leftCount = 0
		rightCount = 0
		for ch in commands:
			if ch == 'L':
				leftCount += 1
			elif ch == 'R':
				rightCount += 1
		return rightCount + leftCount + 1
sol = Solution()
n = int(input().strip())
commands = input().strip()
print(sol.solve(commands=commands))


right = 0
left = 0
Sum = 0
sequenceLen = int(input(''))
getCommand = input('')
for i in getCommand:
	if i is 'L':
		left += 1
	elif i is 'R':
		right += 1
Sum = left + right + 1
print(Sum)


num = int(input())
string = input()
print(str(num + 1))


n = int(input())
s = input()
(l, r) = (0, 0)
for c in s:
	l += c == 'L'
	r += c == 'R'
print(int(l + r) + 1)


num = int(input())
str1 = input()
print(num + 1)


y = int(input())
(L, R) = (0, 0)
z = list(input())
for i in range(0, y):
	if z[i] == 'l':
		L = L + 1
	else:
		R = R + 1
res = L + R + 1
print(res)


n = int(input())
c = input()
lC = 0
rC = 0
for ch in c:
	if ch == 'L':
		lC += 1
	else:
		rC += 1
print(lC + rC + 1)


n = int(input())
s = input()
ct1 = 0
ct2 = 0
for i in range(len(s)):
	if s[i] == 'L':
		ct1 += 1
	else:
		ct2 += 1
print(ct1 + ct2 + 1)


n = int(input())
s = input()
l = [-1 if s[i] == 0 else 1 for i in range(n)]
print(l.count(1) + l.count(-1) + 1)


import sys
N = int(sys.stdin.readline())
word = str(sys.stdin.readline().strip())
print(N + 1)


n = int(input())
s = input()
l_count = 0
r_count = 0
for i in range(len(s)):
	if s[i] == 'L':
		l_count += 1
	if s[i] == 'R':
		r_count += 1
print(l_count + r_count + 1)


n = int(input())
s = input()
cntl = 0
cntr = 0
for i in range(n):
	if s[i] == 'L':
		cntl += 1
	elif s[i] == 'R':
		cntr += 1
print(cntl + cntr + 1)


count = int(input())
comm = input()
print(count + 1)


n = int(input())
s = input()
qL = s.count('L')
qR = s.count('R')
m = qL + qR
print(m + 1)


n = int(input())
s = input()
ls = 0
rs = 0
for ch in s:
	if ch == 'R':
		rs += 1
	else:
		ls += 1
print(ls + rs + 1)


n = int(input())
s = input()
(nl, nr) = (s.count('L'), s.count('R'))
print(nl + nr + 1)


moves = int(input())
directions = input()
print(directions.count('R') + directions.count('L') + 1)


a = int(input())
(l, r) = (0, 0)
b = list(map(str, input()))
for i in range(len(b)):
	if b[i] == 'L':
		l += 1
	elif b[i] == 'R':
		r += 1
print(l + r + 1)


def main():
	n = int(input())
	s = input()
	l = 0
	r = 0
	for c in s:
		if c == 'R':
			r += 1
		else:
			l += 1
	print(l + r + 1)
main()


I = int(input())
x = input()
c = 0
r = 0
t = 0
for i in range(I):
	if x[i] == 'L':
		c = c - 1
	else:
		r = r + 1
for j in range(c, r + 1):
	t += 1
print(t)


n = int(input())
s = input()
l_num = s.count('L')
r_num = s.count('R')
print(l_num + r_num + 1)


p = int(input())
pp = input()
print(p + 1)


input()
commands = input()
left = commands.count('L') * -1
right = commands.count('R')
print(len(range(left, right + 1)))


from math import *
from collections import *
import sys
sys.setrecursionlimit(10 ** 9)
n = int(input())
a = input()
print(n + 1)


n = int(input())
t = list(input().rstrip().split())
n = n + 1
print(n)


t = int(input())
s = input()
l = 0
r = 0
for i in s:
	if i == 'L':
		l = l - 1
	else:
		r = r + 1
print(r + 1 + abs(l))


n = int(input())
s = input()
lst = list(s)
count_L = lst.count('L')
count_R = lst.count('R')
res = count_R + count_L + 1
print(res)


tc = int(input())
print(tc + 1)


n = int(input())
string = input()
l = -string.count('L')
b = string.count('R')
if l == 0:
	print(b + 1)
elif b == 0:
	print(abs(l) + 1)
else:
	print(abs(l) + b + 1)


n = int(input())
command = input()
command = list(command)
maxi = 0
mini = 0
for x in command:
	if x == 'L':
		mini -= 1
	else:
		maxi += 1
print(maxi - mini + 1)


t = int(input())
s = input()
cr = 0
cl = 0
for i in s:
	if i == 'R':
		cr = cr + 1
	else:
		cl = cl + 1
ans = cr + cl + 1
print(ans)


import sys
n = int(sys.stdin.readline().rstrip())
s = sys.stdin.readline().rstrip()
c_L = 0
C_R = 0
print(n + 1)


import sys

def main():
	n = int(sys.stdin.readline())
	s = sys.stdin.readline()
	sys.stdout.write(str(s.count('R') + s.count('L') + 1) + '\n')
main()


def count(movetype):
	counter = 0
	if movetype == 'L':
		for i in range(len(setofmoves)):
			if setofmoves[i] == 'L':
				counter += 1
	elif movetype == 'R':
		for i in range(len(setofmoves)):
			if setofmoves[i] == 'R':
				counter += 1
	return counter
n = int(input())
setofmoves = input()
if n == len(setofmoves):
	t1 = -1 * count('L')
	t2 = count('R')
	dist = -1 * t1 + t2 + 1
	print(dist)


n = int(input())
a = input()
a1 = a.count('L')
a2 = a.count('R')
print(a1 + a2 + 1)


from collections import Counter
_ = input()
cmd = input().strip()
counts = Counter(cmd)
max_left = counts.get('L', 0)
max_right = counts.get('R', 0)
print(max_left + max_right + 1)


n = int(input())
(l, r) = (0, 0)
command = input()
for i in range(n):
	if command[i] == 'L':
		l += 1
	else:
		r += 1
print(l + r + 1)


n = int(input())
str = input()
c1 = 0
c2 = 0
k = 0
for i in str:
	if i == 'L':
		c1 += 1
	else:
		c2 += 1
if (c1 + c2) % 2 == 0:
	k = c1 + c2 + 1
else:
	k = c1 + c2 + (c1 + c2) % 2
print(k)


def count_possibilities(moves):
	l_count = 0
	r_count = 0
	for m in moves:
		if m == 'L':
			l_count += 1
		else:
			r_count += 1
	return l_count + r_count + 1

def solution(inp):
	return count_possibilities(inp)

def main():
	length = eval(input())
	result = solution(input())
	print(result)
main()


m = int(input())
a = str(input())
(p, q) = (0, 0)
for i in a:
	if i == 'L':
		p += 1
	else:
		q += 1
print(p + q + 1)


size = int(input())
directions = input()
leftCount = directions.count('L')
rightCount = directions.count('R')
print(leftCount + rightCount + 1)


n = input()
str = input()
n = 0
for i in str:
	if i == 'L':
		n = n + 1
	else:
		n = n + 1
print(n + 1)


num = input()
lr = input()
l = lr.count('L')
r = lr.count('R')
i = l + r + 1
print(i)


n = int(input())
strs = input()
left = 0
right = 0
for i in strs:
	if i == 'L':
		left += 1
	else:
		right += 1
diff = abs(0 - left) + abs(0 - right) + 1
print(diff)


a = int(input())
st = input()
print(a + 1)


input()
a = input()
l = a.count('L')
r = a.count('R')
print(l + r + 1)


N = int(input())
string = input()
count1 = 0
count2 = 0
for i in string:
	if i == 'L':
		count1 -= 1
	else:
		count2 += 1
print(count2 - count1 + 1)


a = input()
b = input()
countl = 0
countr = 0
for i in b:
	if i == 'L':
		countl = countl - 1
	else:
		countr = countr + 1
print(countr - countl + 1)


n = int(input())
s = input()
countL = 0
countR = 0
for i in range(n):
	if s[i] == 'R':
		countR += 1
	else:
		countL += 1
print(countR + countL + 1)


n = int(input())
s = list(map(str, input()))
l = 0
r = 0
for i in range(n):
	if s[i] == 'L':
		l += 1
	else:
		r += 1
left = 0 - l
right = 0 + r
print(right - left + 1)


n = int(input())
s = input()
x = 0
lst = list(s)
n_l = lst.count('L')
n_r = lst.count('R')
mi = x - n_l
ma = x + n_r
ran = ma - mi
print(ran + 1)


def game(s):
	l = 0
	r = 0
	ans = [0]
	for i in s:
		if i == 'L':
			ans.append(l - 1)
			l -= 1
		else:
			ans.append(r + 1)
			r += 1
	print(len(ans))
n = int(input())
s = input()
game(s)


import sys
import math
fileoperation = 0
if fileoperation:
	orig_stdout = sys.stdout
	orig_stdin = sys.stdin
	inputfile = open('W:/Competitive Programming/input.txt', 'r')
	outputfile = open('W:/Competitive Programming/output.txt', 'w')
	sys.stdin = inputfile
	sys.stdout = outputfile
mod = 1000000007

def nospace(l):
	ans = ''.join((str(i) for i in l))
	return ans
t = 1
for tt in range(t):
	n = int(input())
	print(n + 1)
if fileoperation:
	sys.stdout = orig_stdout
	sys.stdin = orig_stdin
	inputfile.close()
	outputfile.close()


from math import ceil

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(mi())

def si():
	return input()
n = ii()
s = si()
s = list(s)
x = s.count('L')
y = s.count('R')
print(x + y + 1)


a = int(input())
b = input()
qLetrasL = b.count('L')
qLetrasR = b.count('R')
resposta = qLetrasL + qLetrasR
print(resposta + 1)


m = int(input())
n = list(input())
x = y = j = 0
for i in n:
	if i == 'L':
		x = x + 1
	else:
		y = y - 1
for i in range(y, x + 1, 1):
	j = j + 1
print(j)


len = int(input())
cmd = input()[:len]
print(len + 1)


n = int(input())
commands = input()
l_com = commands.count('L')
r_com = commands.count('R')
print(l_com + r_com + 1)


n = int(input())
_ = input()
print(n + 1)


class solution:

	def __init__(self, n, s):
		self.n = n
		self.s = s
		self.answer = 0

	def calculation(self):
		self.answer = self.n + 1
n = int(input())
s = input()
root = solution(n, s)
root.calculation()
print(root.answer)


N = int(input())
s = list(input())
L = s.count('L')
R = s.count('R')
print(L + R + 1)


import math
import os
import random
import re
import sys
from collections import Counter
n = int(input())
s = Counter(input())
print(s['L'] + s['R'] + 1)


n = int(input())
s = input()
kr = 0
kl = 0
for i in s:
	if i == 'L':
		kl += 1
	else:
		kr += 1
print(kl + kr + 1)


from sys import setrecursionlimit
setrecursionlimit(1000000)
n = int(input())
input()
print(n + 1)


n = int(input())
moves = input()
L = moves.count('L')
R = moves.count('R')
print(L + R + 1)


def f():
	n = int(input())
	s = input()
	left = 0
	right = 0
	for i in range(n):
		if s[i] == 'L':
			left += 1
		elif s[i] == 'R':
			right += 1
	return left + right + 1
print(f())


n = int(input())
s = input()
l = s.count('L')
r = s.count('R')
sol = l + r + 1
print(sol)


N = int(input())
S = input()
l = 0
r = 0
for i in range(len(S)):
	if S[i] == 'L':
		l += 1
	else:
		r += 1
print(l + r + 1)


import os
import sys
from io import BytesIO, IOBase

def solution(n, s):
	write(n + 1)

def main():
	n = r_int()
	s = input()
	solution(n, s)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def input():
	return sys.stdin.readline().rstrip('\r\n')

def write(*args, end='\n'):
	for x in args:
		sys.stdout.write(str(x) + ' ')
	sys.stdout.write(end)

def r_array():
	return [int(x) for x in input().split()]

def r_int():
	return int(input())

def w_array(arr):
	for x in arr:
		write(x, end=' ')
	write()
main()


def binarySearch(arr, x):
	l = 0
	r = len(arr) - 1
	while l <= r:
		mid = (l + r) // 2
		if arr[mid] == x:
			return mid
		elif arr[mid] < x:
			l = mid + 1
		else:
			r = mid - 1
	return -1
n = int(input())
s = input()
a = s.count('L')
b = s.count('R')
print(abs(b - -a) + 1)


n = int(input())
s = input()
mn = 0
mx = 0
for c in s:
	if c == 'L':
		mn -= 1
	else:
		mx += 1
print(mx - mn + 1)


n = int(input())
cad = input()
l = cad.count('L')
r = cad.count('R')
print(l + r + 1)


n = int(input())
insrt = input()
countl = 0
countr = 0
for i in insrt:
	if i == 'L':
		countl -= 1
countr = n - abs(countl)
print(abs(countr - countl) + 1)


number = int(input())
string1 = input()
print(number + 1)


import string
n = input()
str = input()
print(len(str) + 1)


n = int(input())
s = input()
cr = 0
cl = 0
for i in range(n):
	if s[i] == 'R':
		cr += 1
	else:
		cl += 1
print(cl + cr + 1)


n = int(input())
s = str(input())
(a, b) = (0, 0)
for i in range(len(s)):
	if s[i] == 'L':
		a = a - 1
	if s[i] == 'R':
		b = b + 1
print(abs(a - b) + 1)


n = int(input())
cmd = input()
maxPos = 0
minPos = 0
for char in cmd:
	if char == 'L':
		minPos -= 1
	else:
		maxPos += 1
print(maxPos - minPos + 1)


from collections import Counter
n = int(input())
a = list(str(input()))
c = Counter(a)
print(sum(c.values()) + 1)


n = int(input())
moves = input()
print(n + 1)


a = int(input())
b = input()
l = b.count('L')
r = b.count('R')
print(l + r + 1)


n = int(input())
comands = input()
count_L = 0
count_R = 0
for c in comands:
	if c == 'L':
		count_L += 1
	else:
		count_R += 1
print(count_L + count_R + 1)


n = int(input())
a = input()
left = 0
right = 0
for i in range(n):
	if a[i] == 'L':
		left += 1
	elif a[i] == 'R':
		right += 1
print(left + right + 1)


x = int(input())
a = list(input())
l = 0
r = 0
for i in range(x):
	if a[i] == 'L':
		l = l - 1
	else:
		r = r + 1
print(r - l + 1)


n = int(input())
word = str(input())
print(n + 1)


n = input()
print(len(input()) + 1)


n = int(input())
x = input()
y = x[0:n]
left = 0
right = 0
for i in y:
	if i == 'L':
		left -= 1
	elif i == 'R':
		right += 1
print(right - left + 1)


def main():
	a = int(input())
	line = input()
	print(len(line) + 1)
t = 1
for i in range(t):
	main()


num = int(input())
a = input()
print(num + 1)


input()
commands = input()
l = 0
r = 0
for c in commands:
	if c == 'L':
		l += 1
	elif c == 'R':
		r += 1
	else:
		raise ValueError(f'invalid input: {c}')
print(l + r + 1)


import math
n = input()
s = input()
c_r = 0
c_l = 0
for i in s:
	if i == 'R':
		c_r += 1
	else:
		c_l += 1
print(abs(c_r + c_l + 1))


n = int(input())
l = 0
r = 0
for elem in input():
	if elem == 'l':
		l += 1
	else:
		r += 1
print(l + r + 1)


while True:
	n = int(input(''))
	if 1 <= n <= 100000:
		break
while True:
	ch = input('')
	if len(ch) == n:
		break
LL = []
LR = []
for x in ch:
	if x == 'L':
		LL += [x]
	else:
		LR += [x]
print(len(LL) + len(LR) + 1)


length = int(input())
s = input()
max_left = 0
max_right = 0
for i in range(length):
	if s[i] == 'L':
		max_left -= 1
	else:
		max_right += 1
print(max_left * -1 + max_right + 1)


N = int(input())
_ = input()
print(1 + N)


def solve():
	n = int(input())
	s = input()
	print(s.count('R') + s.count('L') + 1)
solve()


def main():
	l = int(input())
	left = right = 0
	n = list(input())
	for i in range(l):
		if n[i] == 'L':
			left += 1
		else:
			right += 1
	print(right + left + 1)
main()


a = int(input())
b = input()
ans = 0
ans = int(ans + a + 1)
print(ans)


I = lambda a: a(input())
AI = lambda a: list(map(a, input().split()))
n = I(int)
arr = input()
r = arr.count('R')
l = arr.count('L')
print(r + l + 1)


n = int(input())
c = input()
cl = cr = 0
for i in c:
	if i == 'L':
		cl += 1
	if i == 'R':
		cr += 1
print(cr + cl + 1)


n = int(input())
k = input()
c = k.count('L')
c1 = k.count('R')
print(c + c1 + 1)


n = int(input())
p = input()
l_count = p.count('L')
r_count = p.count('R')
l_count = -1 * l_count
print(r_count - l_count + 1)


n = int(input())
Command = input()
nL = int(Command.count('L'))
nR = n - nL
NumPos = nL + nR + 1
print(NumPos)


import sys
input = sys.stdin.readline
n = int(input())
s = input().rstrip()
left = s.count('L')
right = s.count('R')
print(right + left + 1)


input()
A = input()
print(A.count('L') + A.count('R') + 1)


n = int(input())
command = input()
no = 0
nr = 0
for step in command:
	if step == 'L':
		no += 1
	else:
		nr += 1
rng = no + nr + 1
print(rng)


n = int(input())
s = input()
(l1, r1) = (0, 0)
for i in s:
	if i == 'L':
		l1 += 1
	else:
		r1 += 1
p = l1 + r1 + 1
print(p)


n = int(input())
x = input()
k = list(map(str, x))
d = set(k)
q = 1 + len(d)
w = list(d)
p = 0
for z in range(len(w)):
	q += k.count(w[z]) - 1
print(q)


INT_MAX = 10 ** 18 + 7
MOD = 10 ** 9 + 7

def INPUT():
	return list((int(i) for i in input().split()))

def LIST_1D_ARRAY(n):
	return [0 for _ in range(n)]

def LIST_2D_ARRAY(m, n):
	return [[0 for _ in range(n)] for _ in range(m)]
n = int(input())
print(n + 1)


n = int(input())
l = input()
x = 0
y = 0
for i in l:
	if i == 'L':
		x += 1
	else:
		y -= 1
print(x - y + 1)


n = int(input())
a = str(input())
countl = 0
countr = 0
for i in range(len(a)):
	if a[i] == 'L':
		countl -= 1
	if a[i] == 'R':
		countr += 1
print(abs(countl) + abs(countr) + 1)


N = int(input())
s = input()
m = 0
c = 0
for x in s:
	if x == 'L':
		c = c + 1
	elif x == 'R':
		m = m + 1
s = m + c + 1
print(s)


n = int(input())
li = input()
m = len(li)
x = 0
y = 0
if m == n:
	p = li.count('L')
	q = li.count('R')
	for i in range(p):
		x = x + 1
	for i in range(q):
		y = y + 1
	z = x + y + 1
	print(z)


N = int(input())
S = input()
Lcount = 0
Scount = 0
for i in S:
	if i == 'L':
		Lcount += 1
	if i == 'R':
		Scount += 1
print(Lcount + Scount + 1)


n = int(input())
a = input()
c = d = 0
for i in range(len(a)):
	if a[i] == 'L':
		c = c + 1
	else:
		d = d + 1
print(c + d + 1)


n = int(input())
s = input()
nr = 0
nl = 0
for i in range(n):
	if s[i] == 'R':
		nr += 1
	else:
		nl += 1
print(nl + nr + 1)


def main():
	n = input()
	l = 0
	r = 0
	command = input()
	for c in command:
		if c == 'L':
			l += 1
		else:
			r += 1
	print(l + r + 1)
main()


qw = int(input())
str = input()
n = str.count('L')
p = str.count('R')
print(n + p + 1)


N = int(input())
string = input()
dict = {'L': 0, 'R': 0}
for i in string:
	if i == 'L':
		dict[i] -= 1
	else:
		dict[i] += 1
print(dict['R'] - dict['L'] + 1)


def main():
	n = eval(input())
	s = input()
	print(n + 1)
main()


n = int(input())
left = 0
right = 0
move = str(input())
for i in range(n):
	if move[i] == 'L':
		left += 1
	elif move[i] == 'R':
		right += 1
print(1 + left + right)


n = int(input())
a = list(input())
t = a.count('L')
s = a.count('R')
print(t + s + 1)


import math
x = input()
y = input()
r = 0
for i in range(0, len(y)):
	if y[i] == 'R':
		r += 1
l = len(y) - r
print(l + r + 1)


n = int(input())
s = input()
countR = 0
countL = 0
for x in s:
	if x is 'R':
		countR += 1
	elif x is 'L':
		countL += 1
print(countR + countL + 1)


n = int(input().strip())
print(n + 1)


n = int(input())
l = input()
(c, f) = (0, 0)
if 'L' in l:
	m = l.count('L')
	f = 1
if 'R' in l:
	n = l.count('R')
	c = 1
if f == 1 and c == 1:
	print(m + n + 1)
elif f == 1:
	print(m + 1)
elif c == 1:
	print(n + 1)
else:
	print(0)


from collections import *
from sys import *
inp = stdin.readline
out = print
num = int(inp())
command = list(inp())
co = Counter(command)
print(co['L'] + co['R'] + 1)


def mezoPlayingZoma(n, s):
	cntL = 0
	cntR = 0
	for ch in s:
		if ch == 'L':
			cntL += 1
		else:
			cntR += 1
	res = cntL + cntR + 1
	print(res)
n = int(input())
s = input()[:n]
mezoPlayingZoma(n, s)


a = input()
b = input()
print(len(b) + 1)


n = int(input())
l = list(input())
q = l.count('L')
w = l.count('R')
print(q + w + 1)


n = int(input())
s = input()
cL = s.count('L')
cR = s.count('R')
print(cL + cR + 1)


from math import *
from copy import *
from string import *
from random import *
from sys import stdin
from sys import maxsize
from operator import *
from itertools import *
from collections import Counter
import math

def bin1(l, r, k, t, b, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		v = k ** mid
		if v == val:
			return v
		elif v > val:
			ans = mid
			return bin1(mid + 1, r, k, t, b, val, ans)
		else:
			return bin1(l, mid - 1, k, t, b, val, ans)

def bin2(l, r, k, t, b, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		v = t * k ** mid + b * mid
		if v == val:
			return v
		elif v > val:
			ans = mid
			return bin2(l, mid - 1, k, t, b, val, ans)
		else:
			return bin2(mid + 1, r, k, t, b, val, ans)

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	l = []
	for i in range(2, n + 1):
		if prime[i]:
			l.append(i)
	return l

def bin(l, r, ll, val):
	if l > r:
		return -1
	else:
		mid = (l + r) // 2
		if val >= ll[mid][0] and val <= ll[mid][1]:
			return mid
		elif val < ll[mid][0]:
			return bin(l, mid - 1, ll, val)
		else:
			return bin(mid + 1, r, ll, val)

def deci(n):
	s = ''
	while n != 0:
		if n % 2 == 0:
			n = n // 2
			s = '0' + s
		else:
			n = n // 2
			s = '1' + s
	return s

def diff(s1, s2):
	if len(s1) < len(s2):
		v = len(s1)
		while v != len(s2):
			s1 = '0' + s1
			v = v + 1
	else:
		v = len(s2)
		while v != len(s1):
			s2 = '0' + s2
			v = v + 1
	c = 0
	for i in range(len(s1)):
		if s1[i:i + 1] != s2[i:i + 1]:
			c = c + 1
	return c
from sys import stdin, stdout

def fac(a, b):
	v = a
	while a != b:
		v *= a - 1
		a = a - 1
	return v

def bino(l, r, n):
	if l > r:
		return -1
	else:
		mid = (l + r) // 2
		val1 = math.log(n / mid + 1, 2)
		val2 = int(val1)
		if val1 == val2:
			return val1
		elif val1 < 1.0:
			return bino(l, mid - 1, n)
		else:
			return bino(mid + 1, r, n)

def binary(l, r, ll, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		if ll[mid] == val:
			return ll[mid]
		elif ll[mid] < val:
			ans = ll[mid]
			return binary(mid + 1, r, ll, val, ans)
		else:
			return binary(l, mid - 1, ll, val, ans)

def check(n):
	v = 1
	while n != 0:
		if n % 10 == 0 or n % 10 == 1:
			n = n // 10
		else:
			v = 0
			break
	return v
n = int(stdin.readline())
s = str(input())
print(n + 1)


n = int(input())
st = input()
print(len(st) + 1)


o = 0
l = 0
n = int(input())
m = input()
for i in range(0, n):
	if m[i] == 'L':
		o = o + 1
	else:
		l = l + 1
print(o + l + 1)


import sys
sys.stdin.readline()
line = sys.stdin.readline()
print(len(line))


n = int(input())
o = str(input())
s = list(o)
l = 0
r = 0
for i in range(n):
	if s == 'L':
		l += 1
	else:
		r += 1
print(l + r + 1)


n = int(input())
x = input()
l = x.count('L')
r = x.count('R')
if l == r:
	print(2 * l + 1)
else:
	print(l + r + 1)


num = int(input())
com = input()
com = list(com)
countl = 0
countr = 0
for i in range(num):
	if com[i] == 'L':
		countl += 1
	else:
		countr += 1
print(countr + countl + 1)


def main():
	n = int(input())
	commands = input()
	l_cmds = 0
	r_cmds = 0
	for i in range(n):
		if commands[i] is 'L':
			l_cmds += 1
		else:
			r_cmds += 1
	possibilities = r_cmds + l_cmds + 1
	print(possibilities)
	return
main()


n = int(input())
s = input()
x = 0
for i in s:
	if i == 'R':
		x += 1
p = n - x
print(x + p + 1)


n = input()
s = input()
maxr = 0
maxl = 0
for i in s:
	if i == 'L':
		maxr += 1
	else:
		maxl += 1
print(maxr + maxl + 1)


test = int(input())
s = input()
i = 0
l = 0
r = 0
while i < test:
	if s[i] == 'L':
		l += 1
	else:
		r += 1
	i += 1
print(l + r + 1)


def pos(s):
	return len(s) + 1
n = int(input())
s = input()
print(pos(s))


n = int(input())
d = input()
print(n + 1)


t = int(input())
s = input()
n1 = s.count('L')
n2 = s.count('R')
print(n1 + n2 + 1)


n = int(input())
str = input()
str = str.upper()
lc = 0
rc = 0
for i in range(n):
	if str[i] == 'L':
		lc = lc - 1
	elif str[i] == 'R':
		rc = rc + 1
count = lc * -1 + rc + 1
print(count)


import re

def post(n, x):
	a = len(re.findall('L', x))
	b = len(re.findall('R', x))
	return a + b + 1
t = int(input())
y = input()
r = post(t, y)
print(r)


n = int(input().strip())
string = input().strip()
ans = 1
ans += int(string.count('L'))
ans += int(string.count('R'))
print(ans)


def solve():
	n = int(input())
	s = input()
	(l_count, r_count) = (0, 0)
	for i in range(n):
		if s[i] == 'L':
			l_count += 1
		elif s[i] == 'R':
			r_count += 1
	return l_count + r_count + 1
print(solve())


def mezo(mov):
	(lcount, rcount) = (mov.count('L'), mov.count('R'))
	return rcount + lcount + 1
lenstr = int(input())
str = input()
print(mezo(str))


import sys
input = sys.stdin.readline
N = int(input())
S = input().rstrip()
l = 0
r = 0
for s in S:
	if s == 'L':
		l -= 1
	else:
		r += 1
print(r - l + 1)


(n, s) = (input(), input())
cL = cR = 0
for i in s:
	if i == 'L':
		cL += 1
	else:
		cR += 1
print(cR + cL + 1)


n = int(input())
l = 0
r = 0
cmnd = input()
print(n + 1)


n = int(input())
s = input()
(ctr1, ctr2) = (0, 0)
for i in s:
	if i == 'L':
		ctr1 -= 1
	else:
		ctr2 += 1
print(abs(ctr1 - ctr2 - 1))


def main():
	n = int(input())
	l = input()
	lc = rc = 0
	for i in l:
		if i == 'L':
			lc += 1
		else:
			rc += 1
	print(lc + rc + 1)
main()


a = int(input())
b = input()
n = 1
for i in range(0, a):
	if b[i] == 'R' or b[i] == 'L':
		n += 1
print(n)


s = int(input())
v = input()
print(len(v) + 1)


n = int(input())
a = input()
lans = -1 * a.count('L')
rans = a.count('R')
m = [lans + rans] + [lans] + [0] + [rans]
print(max(m) - min(m) + 1)


n = int(input())
str = input()
lc = 0
rc = 0
for i in str:
	if i == 'l':
		lc += 1
	else:
		rc += 1
print(lc + rc + 1)


def solve():
	n = int(input())
	commands = input()
	min = 0
	max = 0
	for s in commands:
		if s == 'L':
			min -= 1
		elif s == 'R':
			max += 1
	print(max - min + 1)
solve()


n = int(input())
lis = list(input())
(left, right) = (0, 0)
ans = 1
for i in lis:
	if i == 'L':
		left += 1
	else:
		right += 1
print(ans + left + right)


n = int(input())
s = input()
right = 0
left = 0
for i in s:
	if i == 'R':
		right += 1
	else:
		left += 1
left = 0 - left
print(right - left + 1)


import math
from collections import defaultdict, Counter, deque
INF = float('inf')

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a

def primeFactor(n):
	if n % 2 == 0:
		return 2
	i = 3
	while i ** 2 <= n:
		if n % i == 0:
			return i
		i += 1
	return n

def main():
	n = int(input())
	s = input()
	l = 0
	r = 0
	for i in range(n):
		if s[i] == 'L':
			l += 1
		else:
			r += 1
	print(l + r + 1)
t = 1
for _ in range(t):
	main()


n = int(input())
s = list(input())
b = s.count('L') * -1
c = s.count('R')
print(c - b + 1)


n = int(input())
s = input()
i = 0
l = 0
r = 0
while i < len(s):
	l += s[i] == 'L'
	r += s[i] == 'R'
	i += 1
print(l + r + 1)


N = int(input())
S = input()
print(N + 1)


x = int(input())
commands = input()
mostLeftPosition = 0
mostRightPosition = 0
for direction in commands:
	if direction == 'L':
		mostLeftPosition -= 1
	if direction == 'R':
		mostRightPosition += 1
print(-mostLeftPosition + mostRightPosition + 1)


n = int(input())
s = input()
l = 0
r = 0
for e in s:
	if e == 'L':
		l += 1
		continue
	if e == 'R':
		r += 1
		continue
print(l + r + 1)


from collections import Counter
n = int(input())
s = input()
d = dict(Counter(s))
sums = 1
for key in d:
	sums += d[key]
print(sums)


import itertools
t = int(input())
line1 = input()
print(t + 1)


x = int(input())
a = input()
list1 = a.split('L')
list2 = a.split('R')
print(len(list1) + len(list2) - 1)


n = int(input())
x = input()
total = 0
L = 0
R = 0
for i in range(0, n):
	if x[i] == 'L':
		L += 1
	else:
		R += 1
if n == 1:
	total = 2
elif L == R:
	total = L + R + 1
elif L != R:
	total = L + R + 1
print(total)


n = int(input())
inp = input()
print(n + 1)


n = int(input())
s = list(input())
a = s.count('R')
b = s.count('L')
l = [i for i in range(-b, a + 1)]
print(len(l))


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7
n = int(ri())
s = ri()
(cnt1, cnt2) = (0, 0)
for i in s:
	if i == 'L':
		cnt1 += 1
	else:
		cnt2 += 1
print(cnt1 + cnt2 + 1)


import sys
import math

def read_line():
	return sys.stdin.readline()[:-1]

def read_int():
	return int(sys.stdin.readline())

def read_int_line():
	return [int(v) for v in sys.stdin.readline().split()]
n = read_int()
p = read_line()
f = p.count('L')
b = p.count('R')
print(f + b + 1)


import sys
n = int(input())
command = list(sys.stdin.readline().strip())
L = 0
R = 0
for pos in command:
	if pos == 'L':
		L += 1
	else:
		R += 1
print(L + R + 1)


t = int(input())
n = input()
left = right = 0
for i in range(0, t):
	c = n[i]
	if c == 'L':
		left = left + 1
	else:
		right = right + 1
print(left + right + 1)


def solve(n, s):
	numR = 0
	numL = 0
	for c in s:
		if c == 'R':
			numR += 1
		if c == 'L':
			numL += 1
	return 1 + numR + numL
n = int(input())
s = str(input())
print(solve(n, s))


n = int(input())
s = list(input())
(a, b) = (s.count('L'), s.count('R'))
print(a + b + 1)


n = int(input())
p = input()
print(n + 1)


n = int(input())
string = input()
x = 1
l_count = string.count('L')
r_count = string.count('R')
list_terms = list(range(-x * l_count, x * r_count + 1))
print(len(list_terms))


n = int(input())
s = input()
l = s.count('L')
r = s.count('R')
ans = l + r + 1
print(ans)


n = int(input())
x = input()
print(n + 1)


n = int(input())
s = input().strip()
l = s.count('L')
r = n - l
c = 1
print(c + l + r)


n = int(input())
strr = input()
print(n + 1)


from sys import stdin
n = int(stdin.readline().rstrip())
s = stdin.readline().rstrip()
a = 0
b = 0
for i in range(n):
	if s[i] == 'R':
		b += 1
	else:
		a += 1
print(a + b + 1)


n = int(input())
cm = list(input(''))
k = 0
k2 = 0
for i in cm:
	if i == 'L':
		k += 1
	else:
		k2 += 1
print(k2 - k * -1 + 1)


n = int(input())
s = input()
R_number = 0
L_number = 0
for i in range(0, n):
	if s[i] == 'R':
		R_number += 1
	else:
		L_number += 1
print(1 + R_number + L_number)


import collections
n = int(input())
s = str(input())
L = 0
R = 0
for c in s:
	if c == 'L':
		L += 1
	else:
		R += 1
print(1 + L + R)


import sys

def fastio():
	from io import StringIO
	from atexit import register
	global input
	sys.stdin = StringIO(sys.stdin.read())
	input = lambda : sys.stdin.readline().rstrip('\r\n')
	sys.stdout = StringIO()
	register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()

def debug(*var, sep=' ', end='\n'):
	print(*var, file=sys.stderr, end=end, sep=sep)
INF = 10 ** 20
MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
from math import gcd
from math import ceil
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br
(n,) = I()
s = input()
l = s.count('L')
r = s.count('R')
print(l + r + 1)


noOfCommands = input('')
Commands = input('')

def findPos(n, s):
	x = 1
	for command in s:
		if command == 'L':
			x += 1
		if command == 'R':
			x += 1
	return x
print(findPos(noOfCommands, Commands))


def find_possibilities(commands, number_of_commands):
	left_count = 0
	right_count = 0
	for i in range(number_of_commands):
		if commands[i] == 'L':
			left_count += 1
		else:
			right_count += 1
	return left_count + right_count + 1

def main():
	num_of_commands = eval(input())
	commands = input()
	print(find_possibilities(commands, num_of_commands))
main()


n = int(input())
s = input()
(x, y) = (0, 0)
z = 1
for i in s:
	if i == 'L':
		x -= 1
	elif i == 'R':
		y += 1
z += y - x
print(z)


t = int(input())
command = input()
R = command.count('R')
L = command.count('L')
print(R + L + 1)


def f(q):
	l = 0
	r = 0
	for i in q:
		if i == 'L':
			l += 1
		else:
			r += 1
	return r + l + 1
n = int(input())
s = input()
print(f(s))


n = int(input())
lis = list(input())
rec = set()
l = lis.count('L')
r = n - l
print(l + r + 1)


n = int(input())
move = str(input())
print(n + 1)


i = int(input())
k = list(input())
l = 0
r = 0
for p in k:
	if p == 'L':
		l += 1
	else:
		r -= 1
print(l - r + 1)


n = int(input())
m = input()
t = 0
a = m.count('R')
b = -m.count('L')
for i in range(b, a + 1):
	t += 1
print(t)


import sys
x1 = input()
x = input()
if 'L' and 'R' not in x:
	if 'L' in x:
		print(x.count('L') + 1)
	if 'R' in x:
		print(x.count('R') + 1)
	sys.exit()
else:
	print(x.count('L') + x.count('R') + 1)


n = int(input())
s = input()
(nega, posi) = (0, 0)
for item in s:
	if item == 'L':
		nega -= 1
	else:
		posi += 1
print(posi - nega + 1)


n = int(input())
l = list(map(str, input().split()))
print(n + 1)


n = int(input())
s = str(input())
b = list(s)
t = b.count('L')
r = b.count('R')
print(t + r + 1)


t = int(input())
b = input()
l = 0
r = 0
for i in range(t):
	if b[i] == 'R':
		l += 1
	else:
		r += -1
print(l - r + 1)


L = 0
R = 0
n = int(input())
s = list(input().strip())
for i in range(n):
	if s[i] == 'L':
		L += 1
	else:
		R += 1
print(R + L + 1)


def func(n):
	x = input()
	ans = 0
	l_counter = x.count('L')
	r_counter = x.count('R')
	y = 0 - l_counter
	z = 0 + r_counter
	for i in range(y, z + 1):
		ans += 1
	print(ans)
n = int(input())
func(n)


n = int(input())
l = list(map(str, input().split()))
count1 = 0
count2 = 0
for i in range(n):
	if i == 'L':
		count1 += 1
	else:
		count2 += 1
print(count1 + count2 + 1)


t = int(input())
s = str(input())
c = 0
cnt = 0
for i in range(len(s)):
	if s[i] == 'L':
		c -= 1
	else:
		cnt += 1
print(cnt - c + 1)


from sys import stdin, stdout
n = int(stdin.readline())
s = stdin.readline().strip().split()
print(n + 1)


d = int(input())
b = input()
print(d + 1)


from sys import stdin, stdout
x = []
for line in stdin:
	x.append(line.rstrip())
print(len(x[1]) + 1)


import math
t = 1
while t > 0:
	t -= 1
	n = int(input())
	s = input()
	l = s.count('L')
	r = s.count('R')
	print(r - -l + 1)


i = int(input())
CMD = input()
print(i + 1)


import math

def func():
	ctr = int(input())
	inp = input()
	l_ctr = 0
	r_ctr = 0
	for i in inp:
		if i == 'L':
			l_ctr += 1
		else:
			r_ctr += 1
	print(l_ctr + r_ctr + 1)
func()


def mazeFunc():
	n = int(input())
	s = list(input())
	left = s.count('L')
	right = s.count('R')
	ans = left + right + 1
	print(ans)
mazeFunc()


n = int(input())
s = input()
r = s.count('R')
l = n - r
print(r + l + 1)


num = int(input())
commands = input()
print(num + 1)


m = int(input())
s = input()
print(m + 1)


iu = int(input())
arr = [char for char in input()]
L = 0
R = 0
for char in arr:
	if char == 'P':
		R = R + 1
	else:
		L = L + 1
print(L + R + 1)


n = int(input())
s = str(input())
(l, r) = (0, 0)
for x in s:
	if x == 'L':
		l += 1
	else:
		r += 1
print(r + l + 1)


def solve():
	a = int(input())
	st = input()
	print(a + 1)
test = 1
for i in range(test):
	solve()


n = int(input())
x = input()
l = x.count('L')
r = x.count('R')
print(r + l + 1)


n = int(input())
s = input()
cl = 0
cr = 0
x = 0
for i in s:
	if i == 'L':
		cl += 1
	else:
		cr += 1
l = x - cl
r = x + cr
print(abs(r - l) + 1)


n = input()
string = input()
count = 0
count1 = 0
ans = 0
for i in range(len(string)):
	if 'L' == string[i]:
		count = count + 1
	elif 'R' == string[i]:
		count1 = count1 - 1
for m in range(count1, count + 1):
	ans = ans + 1
print(ans)


n = int(input())
sec = input()
print(n + 1)


(_, line) = (input(), input())
nl = len([x for x in line if x == 'L'])
nr = len(line) - nl
print(nl + nr + 1)


(l, h) = (0, 0)
n = int(input())
s = input()
for i in range(n):
	if s[i] == 'L':
		l = l - 1
	elif s[i] == 'R':
		h = h + 1
print(h - l + 1)


import math

class Read:

	@staticmethod
	def string():
		return input()

	@staticmethod
	def int():
		return int(input())

	@staticmethod
	def list(sep=' '):
		return input().split(sep)

	@staticmethod
	def list_int(sep=' '):
		return list(map(int, input().split(sep)))

def solve():
	n = Read.int()
	s = input()
	print(n + 1)
query_count = 1
while query_count:
	query_count -= 1
	solve()


input()
q = input()
print(1 + q.count('L') + q.count('R'))


a = input()
b = input()
(p, q) = (0, 0)
for i in b:
	if i == 'L':
		p += 1
	else:
		q += 1
print(p + q + 1)


n = input()
command = input()
L = command.count('L')
R = command.count('R')
print(1 + L + R)


def main():
	input()
	ch = input()
	print(ch.count('L') + ch.count('R') + 1)
main()


n = int(input())
s = list(input())
num_L = 0
num_R = 0
for i in s:
	if i == 'L':
		num_L += 1
	if i == 'R':
		num_R += 1
print(num_R + num_L + 1)


def main():
	import sys
	input = sys.stdin.readline
	N = int(input())
	s = input()
	n = s.count('R')
	print(n + (N - n) + 1)
main()


n = int(input())
l = 0
r = 0
com = input()
for i in com:
	if i == 'L':
		l += 1
	else:
		r += 1
ans = l + r + 1
print(ans)


num_commands = int(input())
commands = [str(i) for i in input()]
x = commands.count('L')
y = commands.count('R')
print(x + y + 1)


n = input()
xs = input()
die = {}
for i in list(xs):
	if i in die:
		die[i] += 1
	else:
		die[i] = 1
print(sum(die.values()) + 1)


def pos(c):
	maxPos = c.count('R')
	minPos = c.count('L')
	print(maxPos + minPos + 1)
_ = int(input())
pos(input())


n = int(input())
s = str(input())
positions = 1
left = 0
right = 0
print(n + 1)


n = int(input())
s = input()
(r, l) = (0, 0)
for i in s:
	if i == 'R':
		r += 1
	else:
		l -= 1
print(r - l + 1)


import sys
sLength = int(input())
iString = input()
print(sLength + 1)


n = int(input())
s = input()
c = 1
l_c = s.count('L')
r_c = s.count('R')
c += l_c + r_c
print(c)


import sys
a = int(input())
print(a + 1)


n = int(input())
line = input()
print(n + 1)


n = int(input())
stringa = input()
left = 0
right = 0
print(len(stringa) + 1)


import collections as co
n = int(input())
s = input()
print(s.count('L') + s.count('R') + 1)


n = int(input())
s = input()
x = s.count('L')
print(x + n - x + 1)


am = input()
str = input()
L = R = 0
for letter in str:
	if letter == 'L':
		L += 1
	else:
		R += 1
print(L + R + 1)


n = int(input())
s = list(input())
L = 0
R = 0
for item in s:
	if item == 'L':
		L += 1
	else:
		R += 1
print(L + R + 1)


while True:
	try:
		n = int(input())
		s = input()
		print(n + 1)
	except EOFError:
		break


input()
a = list(input())
print(a.count('L') + a.count('R') + 1)


n = int(input())
d = input()
l = d.count('L')
r = d.count('R')
print(l + r + 1)


def inp(dtype=str, strip=True):
	s = input()
	res = [dtype(p) for p in s.split()]
	res = res[0] if len(res) == 1 and strip else res
	return res

def problem1():
	n = inp(int)
	s = inp()
	print(n + 1)
problem1()


n = int(input())
s = input()
p = s.count('R')
print(p + n - p + 1)


import sys
import math
import bisect
import re

def main():
	n = int(input())
	l = 0
	r = 0
	for c in input():
		if c == 'L':
			l += 1
		elif c == 'R':
			r += 1
	print(l + r + 1)
main()


input()
lr = input()
mi = 0
ma = 0
for di in lr:
	if di == 'L':
		mi -= 1
	else:
		ma += 1
print(ma - mi + 1)


t = int(input())
str = input()
x = 0
y = 0
for i in str:
	if i == 'L':
		x = x - 1
	elif i == 'R':
		y = y + 1
print(y - x + 1)


def slipknot(n):
	s = list(input())
	k = s.count('L') + s.count('R') + 1
	print(k)
slipknot(int(input()))


n = int(input())
s = input()
Lefts = 0
Rights = 0
for element in s:
	if element == 'L':
		Lefts += 1
	elif element == 'R':
		Rights += 1
summmm = Rights + Lefts + 1
print(summmm)


x = int(input())
s = input()
print(s.count('L') + s.count('R') + 1)


n = int(input())
s = input()
res = 0
print(n + 1)


a = int(input())
b = []
r = 0
p = 0
for i in range(0, a):
	b.append(0)
for j in range(0, a):
	if b[j] == 'L':
		p = p - 1
	else:
		r = r + 1
print(r - p + 1)


n = int(input())
string = input()
left = 0
right = 0
for i in string:
	if i == 'L':
		left += 1
	if i == 'R':
		right += 1
sum = left + right + 1
print(sum)


from sys import stdin, stdout, exit as sys_ret
(f_input, f_print, f_flush) = (stdin.readline, stdout.write, stdout.flush)
(commands, _) = (int(f_input()), f_input())
f_print(str(commands + 1))


import sys, math, string, bisect
from itertools import *
input = sys.stdin.readline
from collections import deque, defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
S = lambda : input().strip()

def find_lcm(num1, num2):
	if num1 > num2:
		num = num1
		den = num2
	else:
		num = num2
		den = num1
	rem = num % den
	while rem != 0:
		num = den
		den = rem
		rem = num % den
	gcd = den
	lcm = int(int(num1 * num2) / int(gcd))
	return lcm
n = I()
s = input().strip()
l = s.count('L')
r = s.count('R')
print(l + 1 + r)


n = int(input())
new_str = input()
print(new_str.count('L') + new_str.count('R') + 1)


import sys
input = sys.stdin.readline
n = int(input())
S = input().strip()
print(n + 1)


length = int(input())
s = input()
L = s.count('L')
R = len(s) - L
print(R + L + 1)


n = int(input())
ins = input()
print(len(ins) + 1)


import sys
from bisect import bisect_left as bl, bisect_right as br, bisect
import math
from itertools import zip_longest as zl
from itertools import groupby as gb
from itertools import combinations as comb
from itertools import combinations_with_replacement as cwr
from collections import defaultdict as dd
from collections import deque as dq
from collections import Counter as c
mod = pow(10, 9) + 7
mod2 = 998244353

def data():
	return input()

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [[val for i in range(n)] for j in range(m)]
n = int(data())
s = data()
print(n + 1)


f = input()
s = input()
(l, r) = (0, 0)
for i in s:
	if i == 'L':
		l += 1
	else:
		r += 1
print(l + r + 1)


left = 0
right = 0
moves = int(input())
command = input()
for i in command:
	if i == 'L':
		left += 1
	elif i == 'R':
		right += 1
out = left + right + 1
print(out)


l = int(input())
k = input()
print(l + 1)


pos_num = 1
i = int(input())
command = input()
for single_com in command:
	pos_num = pos_num + 1
print(pos_num)


n = int(input())
s = str(input())
p1 = s.count('R')
p2 = s.count('L')
print(p1 + p2 + 1)


import sys

def minp():
	return sys.stdin.readline().strip()

def mint():
	return int(minp())

def mints():
	return map(int, minp().split())

def solve():
	minp()
	s = minp()
	L = s.count('L')
	R = s.count('R')
	print(R + L + 1)
solve()


n = int(input())
s = input()
a = s.count('L')
b = n - a
a = -1 * a
print(b - a + 1)


print(int(input().strip()) + 1)


n = int(input())
com = input()
print(n + 1)


def main():
	n = int(input())
	commands = input()
	Rs = 0
	Ls = 0
	for i in range(n):
		if commands[i] == 'R':
			Rs = Rs + 1
		elif commands[i] == 'L':
			Ls = Ls - 1
	print(Rs - Ls + 1)
main()


kl = int(input())
p = str(input())
print(kl + 1)


def main():
	n = int(input())
	(mi, mx) = (0, 0)
	command = input()
	for x in command:
		if x == 'L':
			mi -= 1
		else:
			mx += 1
	possible = mx - mi
	print(possible + 1)
main()


inp1 = input()
inp = len(input()) + 1
print(inp)


n = int(input())
s = input()
l = list(s)
L = l.count('L')
R = l.count('R')
Ans = R - -L + 1
print(Ans)


n = int(input())
list1 = list(input())
r = list1.count('R')
l = list1.count('L')
print(abs(r + l + 1))


el = int(input())
st = input()
print(el + 1)


n = int(input())
k = input()
(a, b) = (0, 0)
for i in range(n):
	if k[i] == 'L':
		a -= 1
	else:
		b += 1
print(abs(b - a + 1))


import re
n = int(input().strip())
string = input().strip()
left = 0
right = 0
l = re.findall('L', string)
r = re.findall('R', string)
print(len(r) + len(l) + 1)


n = int(input())
commands = input()
(left, right) = (0, 0)
for command in commands:
	if command == 'L':
		left += 1
	else:
		right += 1
print(left + right + 1)


n = int(input())
seq = input()
print(n + 1)


while True:
	n = int(input(''))
	if 1 <= n <= 10 ** 5:
		break
while True:
	x = input('')
	if len(x) == n:
		break
nl = 0
nr = 0
for i in range(n):
	if x[i] == 'R':
		nr = nr + 1
	else:
		nl = nl + 1
print(nl + nr + 1)


x = 0
n = int(input())
s = input()
m = list(s)
m.sort()
try:
	l = m.index('R')
except ValueError:
	l = n
y = -l
z = n - l
print(abs(y - z) + 1)


import sys
input = sys.stdin.readline
from collections import Counter

def main():
	N = int(input())
	S = input().strip()
	c = Counter(S)
	print(abs(c['L'] + c['R'] + 1))
main()


n = int(input())
s = input()
g = [0, 0]
for i in s:
	if i == 'L':
		g[0] -= 1
	else:
		g[1] += 1
print(g[1] - g[0] + 1)


n = int(input())
s = input()
ln = 0
rn = 0
for i in range(len(s)):
	if s[i] == 'L':
		ln = ln + 1
	else:
		rn = rn + 1
t = ln + rn + 1
print(t)


no_of_steps = int(input())
steps = input()
min = 0
max = 0
for i in steps:
	if i == 'L':
		min -= 1
	else:
		max += 1
print(max - min + 1)


lens = int(input())
strs = input()
print(lens + 1)


n = int(input())
a = input()
a = list(a)
p = a.count('L')
q = a.count('R')
p = 0 - p
q = 0 + q
print(q - p + 1)


n = int(input())
pos = input()
print(len(pos) + 1)


n = int(input())
b = input()
lst = []
for i in range(n):
	lst.append(b[i])
l = lst.count('L')
r = lst.count('R')
print(r + l + 1)


qtd = input()
lr = input()
qtd_l = lr.count('L')
qtd_r = lr.count('R')
print(qtd_l + qtd_r + 1)


am = int(input())
n = input()
c = n.count('L')
r = n.count('R')
print(r - -1 * c + 1)


n = int(input())
s = input()
print(1 + len(list(filter(lambda i: i == 'L', s))) + len(list(filter(lambda i: i == 'R', s))))


n = int(input())
st = str(input().strip())
l = 0
r = 0
for ch in st:
	if ch == 'L':
		l += 1
	else:
		r += 1
print(l + r + 1)


n = int(input())
s = input()
w = s.count('L')
print(w + n - w + 1)


i = int(input())
s = input()
l = s.count('L')
r = s.count('R')
print(l + r + 1)


n = int(input())
s = list(input())
x = len(s)
print(int(x) + 1)


n = int(input())
s = input()
L = 0
R = 0
ways = 0
for i in range(n):
	if s[i] == 'L':
		L += 1
	else:
		R += 1
ways = L + R + 1
print(ways)


n = int(input())
ind = input()
cont = 0
for x in range(n):
	if ind[x] == 'L' or ind[x] == 'R':
		cont += 1
print(cont + 1)


vvvvvvvvvvvvv = int(input())
b = input()
print(vvvvvvvvvvvvv + 1)


import math
import sys
import re
n = int(input())
s = input()
d = {}
d['L'] = -1
d['R'] = 1
lc = s.count('L')
lr = s.count('R')
a = -lc
b = lr
print(abs(a - b) + 1)


def problem1(n, s):
	cl = s.count('L')
	cr = s.count('R')
	return cl + cr + 1
n = int(input())
s = input()
print(problem1(n, s))


n = int(input())
string = input()
mx = string.count('R')
mn = string.count('L')
ans = mx + mn + 1
print(ans)


input()
s = input()
print(len(s) + 1)


i1 = int(input())
st = list(input())
le = st.count('L')
ri = st.count('R')
print(le + ri + 1)


n = int(input())
a = input()
t = 0
for j in range(-a.count('L'), a.count('R') + 1, 1):
	t += 1
print(t)


def rahul(word):
	return [char for char in word]
input()
a = rahul(input())
r = 0
b = 0
c = 0
while r < len(a):
	if a[r] == 'L':
		b = b + 1
	else:
		c = c + 1
	r = r + 1
print(b + c + 1)


from collections import Counter
from collections import defaultdict
import math
n = int(input())
s = list(input())
a1 = s.count('L')
a2 = s.count('R')
print(a1 + a2 + 1)


n = int(input())
a = input()
(cntL, cntR) = (0, 0)
for i in range(n):
	if a[i] == 'L':
		cntL += 1
	else:
		cntR += 1
print(cntL + cntR + 1)


n = int(input())
l = str(input())
x = l.count('L')
y = l.count('R')
c = 0
print(x + y + 1 + c)


def main():
	n = int(input())
	cmd = input()
	n = n + 1
	print(n)
main()


n = int(input())
s = input()
a = s.count('L')
b = s.count('R')
c = a + b + 1
print(c)


c = input()
s = input()
l = 0
r = 0
for q in range(0, int(c)):
	if s[q] == 'L':
		l += 1
	else:
		r += 1
print(l + r + 1)


q = int(input())
a = list(map(str, input()))
print(q + 1)


n = int(input())
l = input()
c = l.count('L')
m = l.count('R')
print(m + c + 1)


import sys

def main():
	N = int(sys.stdin.readline())
	command = sys.stdin.readline().replace('\n', '')
	l_cnt = 0
	r_cnt = 0
	for c in command:
		if c == 'L':
			l_cnt += 1
		else:
			r_cnt += 1
	sys.stdout.write(f'{l_cnt + r_cnt + 1}\n')
main()


import math
n = int(input())
moves = [char for char in input()]
l = 0
r = 0
for m in moves:
	if m == 'L':
		l += 1
	if m == 'R':
		r += 1
print(l + r + 1)


n = int(input())
s = input()
if s.find('L') == -1 or s.find('R') == -1:
	print(len(s) + 1)
else:
	r = 0
	for i in s:
		if i == 'R':
			r += 1
	l = (len(s) - r) * -1
	print(r - l + 1)


n = input()
st = input()
l = 0
r = 0
for i in st:
	if i == 'L':
		l = l + 1
	else:
		r = r + 1
print(str(l + r + 1))


t = int(input())
l = input()
print(l.count('R') + l.count('L') + 1)


x = input()
f = input()
n = len(f)
print(n + 1)


a = int(input())
b = input()
(sum1, sum2) = (0, 0)
for i in range(len(b)):
	if b[i] == 'L':
		sum1 -= 1
	else:
		sum2 += 1
print(sum2 - sum1 + 1)


n = int(input())
S = input()
print(S.count('L') + S.count('R') + 1)


from sys import stdin, stdout
n = stdin.readline()
n = int(n)
s = stdin.readline()
lc = s.count('L')
rc = s.count('R')
stdout.write(str(lc + rc + 1))


command_len = int(input())
commands = input()
left_cnt = commands.count('L')
right_cnt = command_len - left_cnt
print(right_cnt + left_cnt + 1)


class MezoZoma:

	def solve(self, string):
		res = {}
		for c in string:
			try:
				res[c] += 1
			except:
				res[c] = 1
		sum = 0
		for k in res.keys():
			sum += res[k]
		return sum + 1
n = int(input())
string = input()
zoma = MezoZoma()
result = zoma.solve(string)
print(result)
string = 'LRLR'


import math
n = int(input())
s = input()
l = 0
r = 0
for i in range(n):
	if s[i] == 'L':
		l = l + 1
	elif s[i] == 'R':
		r = r + 1
print(1 * l + 1 * r + 1)


import sys, itertools
sys.stdin.readline()
s = sys.stdin.readline().strip()
(min, max) = (0, 0)
for c in s:
	if c == 'L':
		min -= 1
	else:
		max += 1
print(abs(min) + max + 1)


a = int(input())
s = input()
print(a + 1)


n = int(input())
move = input()
left = move.count('L') * -1
right = move.count('R')
r = list(range(left, right + 1))
print(len(r))


tam = int(input())
commands = input()
Ls = commands.count('L')
Rs = commands.count('R')
print(Ls + Rs + 1)


n = int(input())
s = input()
a = 0
b = 0
for i in s:
	if i == 'L':
		a = a + 1
	elif i == 'R':
		b = b + 1
d = a + b + 1
print(d)


from collections import deque
import itertools
import operator
import queue
import time
import math
import sys
import os
n = int(input())
s = str(input())
print(len(s) + 1)


n = int(input())
s = input()
nbl = 0
nbr = 0
for c in s:
	if c == 'L':
		nbl += 1
	else:
		nbr += 1
nb = nbr + nbl + 1
print(nb)


import sys
input = sys.stdin.readline
n = input()
command = input().strip()
print(len(command) + 1)


n = int(input())
cmd = input()
print(n + 1)


the_real_thing = int(input(''))
good_for_nothing = input('')
print(the_real_thing + 1)


n = int(input())
ss = list(input())
ans = 0
l = 0
r = 0
for s in ss:
	if s == 'L':
		l += 1
	else:
		r += 1
ans = l + r + 1
print(ans)


(n, s) = (int(input()), input())
(L, R) = (0, 0)
for c in s:
	if c == 'L':
		L += 1
	else:
		R += 1
print(L + R + 1)


command_num = int(input())
str1 = input()
print(command_num + 1)


n = int(input())
s = input()
ne = 0
p = 0
for i in s:
	if i == 'L':
		ne += 1
	else:
		p += 1
if ne and p:
	print(ne + p + 1)
else:
	print(max(p, ne) + 1)


a = int(input())
s1 = str(input())
print(a + 1)


import collections
local = False
if local:
	file = open('A.txt', 'r')

def readInput():
	if local:
		return file.readline()
	else:
		return input()

def zoma(s, n):
	(numl, numr) = (0, 0)
	for c in s:
		if c == 'L':
			numl -= 1
		else:
			numr += 1
	return numr - numl + 1
n = int(readInput())
s = readInput()
print(zoma(s, n))


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_intList_from_str = lambda : list(map(int, list(sys.stdin.readline().strip())))
get_strList_from_str = lambda : list(sys.stdin.readline().strip())
get_int = lambda : int(sys.stdin.readline().strip())
pt = lambda x: sys.stdout.write(str(x))
n = get_int()
command = get_strList_from_str()
L = 0
R = 0
for pos in command:
	if pos == 'L':
		L += 1
	else:
		R += 1
print(L + R + 1)


n = int(input())
a = list(input())
c1 = a.count('L')
c2 = a.count('R')
print(c1 + c2 + 1)


in1 = int(input())
in2 = input()
print(in1 + 1)


inp = input
li = list
iinp = lambda : int(inp())
ent = lambda : map(int, inp().split())
lient = lambda : li(ent())
n = iinp()
izq = der = 0
com = inp()
for i in com:
	if i == 'L':
		izq += 1
	else:
		der += 1
print(der + izq + 1)


n = int(input())
t = input()
x = 0
y = 0
s = list(t)
for i in range(n):
	if s[i] == 'L':
		x -= 1
	elif s[i] == 'R':
		y += 1
print(abs(x) + y + 1)


n = int(input())
x = input()
z = x.count('L')
y = x.count('R')
print(1 + z + y)


def main(cmd):
	l = cmd.count('L')
	r = cmd.count('R')
	print(l + r + 1)

def runner():
	val = input()
	cmd = input()
	main(cmd)
runner()


L = 0
R = 0
N = int(input())
S = input()
for i in range(N):
	if S[i] == 'L':
		L += 1
	else:
		R += 1
print(L + R + 1)


from sys import *
from math import *
n = int(stdin.readline())
s = input()
a = []
l = 0
r = 0
for i in range(n):
	if s[i] == 'R':
		a.append(1)
		r += 1
	else:
		a.append(-1)
		l -= 1
ans = 0
ans = []
for i in range(r + 1):
	ans.append(l + i)
for i in range(abs(l) + 1):
	ans.append(r - i)
ans.sort()
cnt = 1
for i in range(1, len(ans)):
	if ans[i - 1] != ans[i]:
		cnt += 1
print(cnt)


number = int(input())
st = input()
(right, left) = (0, 0)
for i in range(number):
	if st == 'L':
		left -= 1
	else:
		right += 1
temp = abs(left - right)
print(temp + 1)


n = int(input())
s = input()
a = []
if n % 2 == 0:
	k = n // 2
	for i in range(-k, k + 1):
		a.append(i)
	print(len(a))
else:
	k = n // 2
	for i in range(-k, k + 1):
		a.append(i)
	print(len(a) + 1)


n = int(input())
s = input()
p = 0
mn = s.count('L')
mx = s.count('R')
print(mx + mn + 1)


n = int(input())
c = input()
(l, r) = (0, 0)
for v in c:
	if v == 'L':
		l += 1
	else:
		r += 1
print(abs(l) + r + 1)


N = int(input())
s = input()
print(N + 1)


n = int(input())
s = input()
x = len(s)
ans = s.count('L') + s.count('R') + 1
print(ans)


def main(s):
	s = list(s)
	index = 0
	l = 0
	r = 0
	while index < len(s):
		if s[index] == 'L':
			l = l - 1
		elif s[index] == 'R':
			r = r + 1
		index = index + 1
	a = abs(l - r) + 1
	return a
n = int(input())
s = input()
res = main(s)
print(res)


n_commands = int(input())
command = input()
n_commands += 1
print(n_commands)


n = int(input())
s = input()
dict = {'L': 0, 'R': 0}
for i in range(len(s)):
	dict[s[i]] += 1
s = dict['L'] + dict['R']
s += 1
print(s)


from collections import Counter
x = int(input())
s = Counter(list(input()))
print(s['L'] + s['R'] + 1)


n = input()
string = input()
L_count = 0
R_count = 0
for i in string:
	if i == 'L':
		L_count += 1
	if i == 'R':
		R_count += 1
print(L_count + R_count + 1)


N = int(input())
T = input()
L = 0
R = 0
for k in T:
	if k == 'L':
		L += 1
	else:
		R += 1
print(L + R + 1)


num = int(input())
directions = input()
left = 0
right = 0
for x in range(0, num):
	cha = directions[x]
	if cha == 'L':
		left = left + 1
	if cha == 'R':
		right = right + 1
print(left + right + 1)


n = int(input())
k = str(input())
p = tuple(k)
print(len(p) + 1)


n = input()
z = input()
n = int(n)
print(n + 1)


n = int(input())
s = input()
l = len(list(filter(lambda x: x == 'L', s)))
r = n - l
print(l + r + 1)


from collections import Counter
n = int(input())
s = input()
d = Counter(s)
l = d['L']
r = d['R']
print(l + r + 1)


user_input = input()
user_input1 = input()

class Zoma:

	def __init__(self, data):
		self.data = data
		self.left = 1
		self.right = 1
		self.start = 0

	def get_list(self):
		self.data = [item for item in self.data]
		return self.data

	def move(self):
		return self.get_list().pop()

	def all_variations(self):
		return len(self.get_list()) + 1
print(Zoma(user_input1).all_variations())


def main():
	N = int(input())
	s = input()
	(l, r) = (0, 0)
	for i in range(N):
		if s[i] == 'L':
			l += 1
		else:
			r += 1
	print(l + r + 1)
main()


import sys
n = int(sys.stdin.readline())
s = sys.stdin.readline()
x = s.count('R')
y = s.count('L')
sys.stdout.write(str(x + y + 1) + '\n')


n = int(input())
s = str(input())
l = 0
r = 0
res = 0
for i in s:
	if i == 'L':
		l += 1
	elif i == 'R':
		r += 1
x = l + r + 1
print(x)


import sys
input = sys.stdin.readline
import math
n = int(input())
s = input()
s = s.strip()
l = 0
r = 0
for i in range(n):
	if s[i] == 'L':
		l += 1
	else:
		r += 1
print(abs(r + l) + 1)


def conTest(string):
	(l_count, r_count) = (0, 0)
	for sstr in string:
		if sstr == 'L':
			l_count += 1
		elif sstr == 'R':
			r_count += 1
	return l_count + r_count + 1
result = 0
size = eval(input())
string = input()
result = conTest(string)
print(result)


def rint():
	return int(input())

def rints():
	return list(map(int, input().split()))
n = rint()
s = input()
l = s.count('L')
r = n - l
print(l + r + 1)


n = int(input())
s = str(input())[:n]
r = 0
l = 0
f = 0
for i in s:
	if i == 'R':
		r += 1
	elif i == 'L':
		l -= 1
for i in range(l, r + 1):
	f += 1
print(f)


a = int(input(''))
com = input('')
x = 0
for i in com:
	if i == 'L':
		x = x + 1
for j in com:
	if j == 'R':
		x = x + 1
print(x + 1)


n = int(input())
s = input()
s = s.lower()
if n == len(s):
	sum_a = s.count('l')
	sum_b = s.count('r')
	print(len(s) + 1)


from sys import stdin
from collections import deque
mod = 10 ** 9 + 7
import sys
from bisect import bisect_right
from bisect import bisect_left
from collections import defaultdict
from math import sqrt, factorial, gcd, log2, inf, ceil
import heapq
input = lambda : sys.stdin.readline().rstrip()
from sys import stdin, stdout
from heapq import heapify, heappush, heappop
n = int(input())
s = input()
print(abs(s.count('R') + s.count('L')) + 1)


from collections import Counter
n = int(input())
count = Counter(input())
print(count['R'] + count['L'] + 1)


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
n = int(input())
s = input()
L = s.count('L')
R = n - L
print(L + R + 1)


n = int(input())
commands = input()
rs = 0
ls = 0
for i in commands:
	if i == 'R':
		rs += 1
	if i == 'L':
		ls += 1
print(ls + rs + 1)


aaaa = input()
s = input()
l = s.count('L')
r = s.count('R')
print(l + r + 1)


def factorial(n):
	return 1 if n == 1 or n == 0 else n * factorial(n - 1)
b = input()
b = int(b)
print(b + 1)


import sys
n = int(sys.stdin.readline())
s = sys.stdin.readline().strip()
print(n + 1)


import sys
import collections
n = int(sys.stdin.readline())
counter = collections.Counter(sys.stdin.readline())
print(counter['L'] + counter['R'] + 1)


n = int(input())
str = input()
cnt1 = 0
cnt2 = 0
for i in str:
	if i == 'L':
		cnt1 += 1
	else:
		cnt2 += 1
print(cnt1 + cnt2 + 1)


n = input('')
v = input('')
print(int(n) + 1)


import sys

def main():
	_ = int(sys.stdin.readline())
	string = sys.stdin.readline()[:-1]
	l_counts = 0
	r_counts = 0
	for c in string:
		if c == 'L':
			l_counts += 1
		else:
			r_counts += 1
	sys.stdout.write(f'{l_counts + r_counts + 1}\n')
main()


n = int(input())
s = input().strip().split()
print(n + 1)


i = input()
(left, right) = (0, 0)
for x in input():
	if x == 'L':
		left += 1
	else:
		right += 1
print(left + right + 1)


input()
s = input()
left = s.count('L')
right = s.count('R')
print(right + left + 1)


n = int(input())
si = input()
l = si.count('L')
r = si.count('R')
print(l + r + 1)


import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *

class Scanner:

	@staticmethod
	def int():
		return int(sys.stdin.readline().rstrip())

	@staticmethod
	def string():
		return sys.stdin.readline().rstrip()

	@staticmethod
	def map_int():
		return [int(x) for x in Scanner.string().split()]

	@staticmethod
	def string_list(n):
		return [input() for i in range(n)]

	@staticmethod
	def int_list_list(n):
		return [Scanner.map_int() for i in range(n)]

	@staticmethod
	def int_cols_list(n):
		return [int(input()) for i in range(n)]

class Math:

	@staticmethod
	def gcd(a, b):
		if b == 0:
			return a
		return Math.gcd(b, a % b)

	@staticmethod
	def lcm(a, b):
		return a * b // Math.gcd(a, b)

	@staticmethod
	def divisor(n):
		res = []
		i = 1
		for i in range(1, int(n ** 0.5) + 1):
			if n % i == 0:
				res.append(i)
				if i != n // i:
					res.append(n // i)
		return res

	@staticmethod
	def round_up(a, b):
		return -(-a // b)

	@staticmethod
	def is_prime(n):
		if n < 2:
			return False
		if n == 2:
			return True
		if n % 2 == 0:
			return False
		d = int(n ** 0.5) + 1
		for i in range(3, d + 1, 2):
			if n % i == 0:
				return False
		return True

class PriorityQueue:

	def __init__(self, l=[]):
		self.q = l
		heapq.heapify(self.q)
		return

	def push(self, n):
		heapq.heappush(self.q, n)
		return

	def pop(self):
		return heapq.heappop(self.q)

def pop_count(x):
	x = x - (x >> 1 & 6148914691236517205)
	x = (x & 3689348814741910323) + (x >> 2 & 3689348814741910323)
	x = x + (x >> 4) & 1085102592571150095
	x = x + (x >> 8)
	x = x + (x >> 16)
	x = x + (x >> 32)
	return x & 127
MOD = int(1000000000.0) + 7
INF = int(1000000000000000.0)

def main():
	_ = Scanner.int()
	S = Scanner.string()
	L = S.count('L')
	R = S.count('R')
	print(L + R + 1)
main()


n = int(input())
s = input()
count_l = 0
count_r = 0
for c in s:
	if c == 'L':
		count_l += 1
	else:
		count_r += 1
print(n + 1)


n = int(input())
str = input()
num_l = 0
num_r = 0
for i in str:
	if i == 'L':
		num_l += 1
	else:
		num_r += 1
l = 0 - num_l
r = 0 + num_r
print(abs(l - r) + 1)


N = int(input())
L = list(input())
print(N + 1)


n = int(input())
a = input()
q = 0
w = 0
for i in range(n):
	if a[i] == 'R':
		q += 1
	else:
		w += 1
print(w + q + 1)


t = 1
while t:
	n = int(input())
	s = input()
	(l, r) = (0, 0)
	for i in range(n):
		if s[i] == 'L':
			l += 1
		else:
			r += 1
	print(l + r + 1)
	t -= 1


n = input()
s = input()
lefts = 0
rights = 0
for i in s:
	if i == 'L':
		lefts += 1
	else:
		rights += 1
print(rights + lefts + 1)


n = int(input())
c = input()
print(c.count('L') + c.count('R') + 1)


N = int(input())
s = input()
cnt_l = s.count('L')
cnt_r = s.count('R')
print(cnt_l + cnt_r + 1)


import sys
input = sys.stdin.readline
n = int(input())
a = input()
L = 0
R = 0
for i in a:
	if i == 'L':
		L += 1
	if i == 'R':
		R += 1
print(L + R + 1)


int(input())
cmd = input()
l = r = 0
for i in cmd:
	if i == 'L':
		l += 1
	else:
		r += 1
print(l + r + 1)


s = int(input())
st = input()
print(s + 1)


n = int(input())
ls = list(input())
from collections import Counter
count = Counter(ls)
ans = count['L'] + count['R'] + 1
print(ans)


n = input()
s = input()

def num_left(s):
	counter = 0
	for i in s:
		if i == 'L':
			counter = counter + 1
	return counter
num_right = len(s) - num_left(s)
total = num_right + num_left(s) + 1
print(total)


a = int(input())
b = input()
L = 0
R = 0
for i in range(a):
	if b[i] == 'L':
		L += 1
	elif b[i] == 'R':
		R += 1
print(L + R + 1)


import sys
input = sys.stdin.readline
flush = sys.stdout.flush

def iin():
	return int(input())

def lin():
	return list(map(int, input().split()))

def main():
	n = iin()
	s = list(input().strip())
	ans = s.count('L')
	ans = ans + 1 + (n - ans)
	print(ans)
main()


n = int(input())
lr = [i for i in input()]
l = -1 * lr.count('L')
r = lr.count('R')
print(r - l + 1)


n = int(input())
z = input()
s = []
c = 1
for i in z:
	s.append(i)
a = s.count('R')
b = s.count('L')
for i in range(-1 * b, a):
	c += 1
print(c)


def main() -> None:
	n = int(input())
	s = input()
	print(n + 1)
main()


def solve(N, S):
	x = 0
	y = 0
	for i in range(N):
		if S[i] == 'L':
			x -= 1
		else:
			y += 1
	print(abs(x) + y + 1)
n = int(input())
s = str(input())
solve(n, s)


n = int(input())
arr = input()
left = 0
right = 0
for i in arr:
	if i == 'L':
		left += 1
	else:
		right += 1
ans = left + right + 1
print(ans)


n = input()
str = input()
L = 0
R = 0
i = 0
for i in range(len(str)):
	if str[i] == 'L':
		L += 1
	elif str[i] == 'R':
		R += 1
print(L + R + 1)


t = int(input())
str1 = input()
print(t + 1)


noc = int(input())
command = input()
left = 0
right = 0
for i in command:
	if i == 'L':
		left += 1
	else:
		right += 1
print(len(command) + 1)


amountOfMoves = int(input())
moves = input()
leftMoves = moves.count('L')
rightMoves = moves.count('R')
possibleEndings = leftMoves + rightMoves + 1
print(possibleEndings)


a = int(input())
b = list(str(input()))
print(b.count('R') + b.count('L') + 1)


num = input()
name = input()
num = int(num)
print(num + 1)
print('\n')


N = int(input().strip())
S = str(input().strip())
l = 0
r = 0
for c in S:
	if c == 'L':
		l += 1
	else:
		r += 1
print(l + r + 1)


num = int(input())
arr = [i for i in input()][:num]
print(num + 1)


import sys
from math import gcd
from heapq import heappop
from heapq import heappush
from heapq import heapify
from bisect import insort
from bisect import bisect_right
from bisect import bisect_left
from sys import stdin, stdout
from collections import defaultdict, deque
from math import log2, ceil, floor
inp = lambda : int(input())
sip = lambda : input()
mulip = lambda : map(int, input().split())
lst = lambda : list(map(int, input().split()))
slst = lambda : list(sip())
arr2d = lambda x: [[int(j) for j in input().split()] for i in range(x)]
odds = lambda l: len(list(filter(lambda x: x % 2 != 0, l)))
evens = lambda l: len(list(filter(lambda x: x % 2 == 0, l)))
mod = pow(10, 9) + 7
Judge = 0
if Judge:
	sys.stdin = open('input.in', 'r')
n = inp()
s = input()
(l, r) = (0, 0)
for i in s:
	if i == 'R':
		r += 1
	else:
		l += 1
print(r + l + 1)


n = int(input().strip())
string = input().strip()
left = 0
right = 0
for i in string:
	if i == 'L':
		left -= 1
	elif i == 'R':
		right += 1
print(right - left + 1)


n = input()
s = input()
l = list(s)
a = 0
b = 0
for i in range(len(l)):
	if l[i] == 'L':
		a -= 1
	elif l[i] == 'R':
		b += 1
	else:
		continue
print(b - a + 1)


a = int(input())
b = input()
s = 1
s = s + b.count('L')
s = s + b.count('R')
print(s)


a = int(input())
b = input()
Lefts = b.count('L')
Rights = b.count('R')
Count = 1
if Lefts > 0:
	Count += Lefts
if Rights > 0:
	Count += Rights
print(Count)


trash = input()
entry = input()
r_c = 0
l_c = 0
for c in entry:
	if c == 'L':
		l_c = l_c + 1
	else:
		r_c = r_c + 1
print(l_c + r_c + 1)


n = int(input())
s1 = input()
print(n + 1)


a = int(input())
b = input()
c = b.count('L')
d = b.count('R')
e = [0]
for i in range(1, c + 1):
	e.append(-i)
for i in range(1, d + 1):
	e.append(i)
print(len(e))


n = int(input())
cmds = input()
print(n + 1)


dic = {'L': 0, 'R': 0}
n = int(input())
x = input()
for i in x:
	if i == 'L':
		dic['L'] -= 1
	else:
		dic['R'] += 1
print(dic['R'] - dic['L'] + 1)