Let's define a split of $n$ as a nonincreasing sequence of positive integers, the sum of which is $n$. 

For example, the following sequences are splits of $8$: $[4, 4]$, $[3, 3, 2]$, $[2, 2, 1, 1, 1, 1]$, $[5, 2, 1]$.

The following sequences aren't splits of $8$: $[1, 7]$, $[5, 4]$, $[11, -3]$, $[1, 1, 4, 1, 1]$.

The weight of a split is the number of elements in the split that are equal to the first element. For example, the weight of the split $[1, 1, 1, 1, 1]$ is $5$, the weight of the split $[5, 5, 3, 3, 3]$ is $2$ and the weight of the split $[9]$ equals $1$.

For a given $n$, find out the number of different weights of its splits.


-----Input-----

The first line contains one integer $n$ ($1 \leq n \leq 10^9$).


-----Output-----

Output one integer — the answer to the problem.


-----Examples-----
Input
7

Output
4

Input
8

Output
5

Input
9

Output
5



-----Note-----

In the first sample, there are following possible weights of splits of $7$:

Weight 1: [$\textbf 7$] 

Weight 2: [$\textbf 3$, $\textbf 3$, 1] 

Weight 3: [$\textbf 2$, $\textbf 2$, $\textbf 2$, 1] 

Weight 7: [$\textbf 1$, $\textbf 1$, $\textbf 1$, $\textbf 1$, $\textbf 1$, $\textbf 1$, $\textbf 1$]

Source: codeforces | Difficulty: EASY
Tags: Mathematics


Solutions:
def do():
	n = int(input())
	print(n // 2 + 1)
do()

def resolve():
	from pprint import pprint
	q = int(input())
	for _ in range(q):
		s = input()
		n = int(input())
		(n, k) = map(int, input().split())
		dat = list(map(int, input().split()))
	dat = [1, 2, 3]
	print(' '.join(list(map(str, res))))
	pass
	import math
	math.ceil(1.2)
	math.floor(1.2)
	round(1.2, 3)


n = int(input())
if n == 1:
	print(1)
elif n == 2 or n == 3:
	print(2)
else:
	print(n // 2 + 1)


k = int(input())
if k == 1:
	print(1)
elif k % 2:
	print((k + 1) // 2)
else:
	print((k + 2) // 2)


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


import atexit
import io
import sys
_INPUT_LINES = sys.stdin.read().splitlines()
input = iter(_INPUT_LINES).__next__
_OUTPUT_BUFFER = io.StringIO()
sys.stdout = _OUTPUT_BUFFER

@atexit.register
def write():
	sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())

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

def __starting_point():
	main()
__starting_point()


import sys
import math
n = int(input())
print(n // 2 + 1)


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


n = int(input())
if n % 2 != 0:
	print((n + 1) // 2)
else:
	print(n // 2 + 1)


n = int(input())
res = 1 + n // 2
print(res)


def Slove():
	n = int(input())
	if n == 1:
		return 1
	return int(n / 2) + 1
print(Slove())


print(int(int(input()) / 2) + 1)


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


def solve(n):
	return n // 2 + 1
k = int(input())
print(solve(k))


def splits(n):
	if n == 1:
		return 1
	else:
		m = n // 2 + 1
		return m
n = int(input())
print(splits(n))


x = int(input())
if x == 1:
	print(1)
elif x % 2 == 1:
	print((x + 1) // 2)
else:
	print(x // 2 + 1)


num = int(input())
print(int(num / 2) + 1)


from math import *
n = int(input())
print(n // 2 + 1)


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


import math
n = int(input())
print(math.floor(n / 2) + 1)


n = int(input())
print(int(n // 2 + 1))
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 0


n = int(input())
ans = n // 2 + 1
print(ans)


import queue

def readTuple():
	return input().split()

def readInts():
	return tuple(map(int, readTuple()))

def solve():
	n = int(input().strip())
	print(n // 2 + 1)

def __starting_point():
	solve()
__starting_point()


N = int(input())
M = N // 2 + 1
print(M)


import math
k = int(input())
f = math.floor(k / 2) + 1
print(f)


from math import ceil
print(int(int(input()) / 2) + 1)


q = int(input())
a = 0 + 1 + 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1
print(q // 2 + 1)


def rick(n):
	if n == 1:
		print(1)
	else:
		print(n // 2 + 1)

def split(n):
	x = 1
	if n == 1:
		s = 18
	else:
		x += 1
		i = 2
		j = int((n + 1) // 2)
		while i < n + 1:
			if j < 2:
				i += 1
				j = (n + 1) // i
			elif j == 0:
				i += 1
				j = n // i
			elif n - i * j > -1:
				x += 1
				i += 1
				j = n // i
			else:
				j -= 1
	print(x)
n = input()
n = int(n)
rick(n)


n = input()
nn = int(n)
print(nn // 2 + 1)


n = eval(input(''))
n = n / 2 + 1
print('%d' % n)


m = int(input())
print(m // 2 + 1)


n = int(input())
count = n // 2 + 1
print(count)


from math import *
from cmath import *
from itertools import *
from decimal import *
from fractions import *
from sys import *
from types import CodeType, new_class
n = int(input())
print(n // 2 + 1)


n = int(input())
sum = 0
sum = n // 2 + 1
print(sum)


T_ON = 0
DEBUG_ON = 1
MOD = 998244353

def solve():
	n = read_int()
	print(n // 2 + 1)

def main():
	T = read_int() if T_ON else 1
	for i in range(T):
		solve()

def debug(*xargs):
	if DEBUG_ON:
		print(*xargs)
from collections import *
import math
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 read_int():
	return int(input())

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

def print_nums(nums):
	print(' '.join(map(str, nums)))

def YES():
	print('YES')

def Yes():
	print('Yes')

def NO():
	print('NO')

def No():
	print('No')

def First():
	print('First')

def Second():
	print('Second')

def fib(n):
	(a, b) = (0, 1)
	for _ in range(n):
		(a, b) = (b, a + b)
	return a

def fib_ns(n):
	assert n >= 1
	f = [0 for _ in range(n + 1)]
	f[0] = 0
	f[1] = 1
	for i in range(2, n + 1):
		f[i] = f[i - 1] + f[i - 2]
	return f

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def xgcd(a, b):
	(x0, x1, y0, y1) = (0, 1, 1, 0)
	while a != 0:
		((q, a), b) = (divmod(b, a), a)
		(y0, y1) = (y1, y0 - q * y1)
		(x0, x1) = (x1, x0 - q * x1)
	return (b, x0, y0)

def lcm(a, b):
	d = gcd(a, b)
	return a * b // d

def is_even(x):
	return x % 2 == 0

def is_odd(x):
	return x % 2 == 1

def modinv(a, m):
	(g, x, _) = xgcd(a, m)
	if g != 1:
		raise Exception('gcd(a, m) != 1')
	return x % m

def mod_add(x, y):
	x += y
	while x >= MOD:
		x -= MOD
	while x < 0:
		x += MOD
	return x

def mod_mul(x, y):
	return x * y % MOD

def mod_pow(x, y):
	if y == 0:
		return 1
	if y % 2:
		return mod_mul(x, mod_pow(x, y - 1))
	p = mod_pow(x, y // 2)
	return mod_mul(p, p)

def mod_inv(y):
	return mod_pow(y, MOD - 2)

def mod_div(x, y):
	return mod_mul(x, mod_inv(y))

def is_prime(n):
	if n == 1:
		return False
	for i in range(2, int(n ** 0.5) + 1):
		if n % i:
			return False
	return True

def gen_primes(n):
	P = [True for _ in range(n + 1)]
	P[0] = P[1] = False
	for i in range(int(n ** 0.5) + 1):
		if P[i]:
			for j in range(2 * i, n + 1, i):
				P[j] = False
	return P
main()


def inpmap():
	return list(map(int, input().split()))
n = int(input())
print(n // 2 + 1)


I = lambda : int(input())
IL = lambda : list(map(int, input().split()))
n = I()
print(n // 2 + 1)


p = int(input())
print(p // 2 + 1)


print(0 - -(int(input()) + 1) // 2)


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


inp = int(input())
if inp == 0:
	print(1)
else:
	print(inp // 2 + 1)


def li():
	return list(map(int, input().split()))
n = int(input())
print(n // 2 + 1)


def a964(n):
	return n // 2 + 1
n = int(input())
print(a964(n))


import math
N = int(input())
if N % 2 == 0:
	print(N // 2 + 1)
else:
	print(math.ceil(N / 2))


import math
n = int(input())
if n == 1:
	print(1)
else:
	print(math.ceil((n + 1) / 2))


def solve(n):
	return n // 2 + 1

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


a = eval(input())
if a == 1:
	print(1)
else:
	print(a // 2 + 1)


inp = int(input())
print(int(inp / 2) + 1)


n = int(input())
l = []
if n != 1:
	print(n // 2 + 1)
else:
	print(1)


def code3(n):
	print(n // 2 + 1)
code3(int(input()))


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_int_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_intList_from_str = lambda : list(map(int, list(sys.stdin.readline().strip())))
get_charList_from_str = lambda : list(sys.stdin.readline().strip())
get_char_list = lambda : sys.stdin.readline().strip().split()
get_int = lambda : int(sys.stdin.readline())
pt = lambda x: sys.stdout.write(str(x))
n = get_int()
print(n // 2 + 1)


from collections import deque
import math
import os
import random
import re
import sys

def main():
	n = int(input())
	ans = n // 2 + 1
	print(ans)
main()


(z, zz) = (input, lambda : list(map(int, z().split())))
(szz, dgraphs, mod) = (lambda : sorted(zz()), {}, 10 ** 9 + 7)
from string import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0 and x != 2:
			return 0
	return 1

def dfs(u, visit, graph):
	visit[u] = True
	for i in graph[u]:
		if not visit[i]:
			dfs(i, visit, graph)
n = int(z())
if n % 2 == 0:
	print(n // 2 + 1)
else:
	print((n + 1) // 2)


n = int(input())
splits = n // 2 + 1
print(splits)


n = int(input())
import math
print(math.ceil(n / 2) + (n + 1) % 2)


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


from math import *
from collections import *

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

def inp_arr():
	return list(map(int, input().split()))
n = int(input())
print(n // 2 + 1)


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


var = int(input())
print(var // 2 + 1)


def razbienie(n):
	if n == 1:
		return 1
	return n // 2 + 1
m = int(input())
print(razbienie(m))


import sys
import math
import bisect
import itertools

def main():
	n = int(input())
	ans = n // 2 + 1
	print(ans)
main()


print((int(input()) >> 1) + 1)


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


y = int(input())
if y % 2 == 0:
	s = y / 2 + 1
else:
	s = (y - 1) / 2 + 1
print(int(s))


from sys import stdin, stdout
import cProfile, math
from collections import Counter
printHeap = str()
test = False
memory_constrained = False

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

def test_print(output):
	if test:
		stdout.write(str(output) + '\n')

def display_list(list1, sep=' '):
	stdout.write(sep.join(map(str, list1)) + '\n')

def get_int():
	return int(stdin.readline().strip())

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

def get_list():
	return list(map(int, stdin.readline().split()))
memory = dict()

def clear_cache():
	global memory
	memory = dict()

def cached_fn(fn, *args):
	global memory
	if args in memory:
		return memory[args]
	else:
		result = fn(*args)
		memory[args] = result
		return result

def main():
	n = get_int()
	print(n // 2 + 1)
cProfile.run('main()') if test else main()


n = int(input())
a = n // 2 + 1
b = 1
c = 1
print(a)


num = int(input())
if num % 2 == 0:
	print(int((num + 2) / 2))
else:
	print(int((num + 1) / 2))


import sys
input = sys.stdin.readline
n = int(input())
print(n // 2 + 1)


def solution(n):
	return int(n / 2) + 1

def answer():
	n = int(input())
	print(solution(n))
answer()


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()
	return n // 2 + 1
print(main())


def main():
	n = int(input())
	if n == 1:
		print(1)
	else:
		left = 2
		right = n // 2
		if left > right:
			print(2)
		else:
			print(right - left + 3)
main()


x = int(input())

def iterator(x):
	ans = 1 + x // 2
	print(ans)
	return ans
iterator(x)


print(int((eval(input()) + 1) / 2 + 0.5))


print((int(input()) + 2) // 2)


n = int(input())
if n == 1:
	print(1)
elif n == 2:
	print(2)
else:
	print(n // 2 + 1)


alph = 'abcdefghijklmnopqrstuvwxyz'
n = int(input())
print(n // 2 + 1)


a = 1
b = 2
c = 3
d = 5
q = 2
n = int(input())
print(int(n / 2 + 1))


exit(print(int(input()) // 2 + 1))


while True:
	try:
		n = int(input())
	except:
		break
	print(n // 2 + 1)


import math
n = int(input())
if n % 2 == 0:
	print(n // 2 + 1)
if n % 2 != 0:
	print(math.ceil(n / 2))


from sys import stdin, stdout

def rint():
	return map(int, stdin.readline().split())
n = int(input())
print(n // 2 + 1)


n = int(input())
(low, high) = (1, n)
while low < high - 1:
	mid = (low + high) // 2
	if n // mid > 1:
		low = mid
	else:
		high = mid
print(high)


integer = int(input())
print(integer // 2 + 1)


t = int(input())
if t % 2 == 0:
	print(t // 2 + 1)
else:
	print((t + 1) // 2)


import sys
import os
import math
n = int(input())
print(math.floor(n / 2) + 1)


x = int(input())
if x % 2 == 0:
	s = x / 2 + 1
else:
	s = (x - 1) / 2 + 1
print(int(s))