Snuke has N integers from 1 to N. He will choose K of them and give those to Takahashi. How many ways are there to choose K consecutive integers? 

Constraints:
- All values in input are integers.
- 1 ≤ K ≤ N ≤ 50

Input:
Input is given from Standard Input in the following format:
N K

Output:
Print the answer.

Sample Input 1:
3 2

Sample Output 1:
2
There are two ways to choose two consecutive integers: (1,2) and (2,3).

Sample Input 2:
13 3

Sample Output 2:
11

# Buggy version:
[N,K]=L()

def L():
    return list(map(int, input().split()))
print(N-K+1)

# Fixed version:
def L():
    return list(map(int, input().split()))

[N,K]=L()


print(N-K+1)

# Buggy version:
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = 1e10

#solve
def solve():
    n, k = LI()
    print(math.factorial(n) // math.factorial(k) // math.factorial(n - k))
    return


#main
if __name__ == '__main__':
    solve()


# Fixed version:
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = 1e10

#solve
def solve():
    n, k = LI()
    print(n-k+1)
    return


#main
if __name__ == '__main__':
    solve()

# Buggy version:
n = int(input())
#m = int(input())
k = int(input())
#n, m = map(int, input().split())
#n, m, k = map(int, input().split())
#a = list(map(int, input().split()))
#table = []
'''
for i in range h:
    temp = list(map(int, input().split()))
    table.append(temp)
'''
print(n-k+1)

# Fixed version:
#n = int(input())
#m = int(input())
#k = int(input())
#n, m = map(int, input().split())
n,  k = map(int, input().split())
#a = list(map(int, input().split()))
#table = []
'''
for i in range h:
    temp = list(map(int, input().split()))
    table.append(temp)
'''
print(n-k+1)

# Buggy version:
list = [int(x) for x in input().split()]
print(list[0] - list[1] + 1]

# Fixed version:
list = [int(x) for x in input().split()]
print(list[0] - list[1] + 1)

# Buggy version:
a,b = map(int, input(),split())
print("{}".format(a-b+1))

# Fixed version:
a,b = map(int, input().split())
print("{}".format(a-b+1))

# Buggy version:
N, K = map(int, input().split())
ans = K - (N - 1)
print(ans)

# Fixed version:
# N = int(input())

N, K = map(int, input().split())

ans = N - (K - 1)

print (ans)

# Buggy version:
[a,b]=map(int,input().split())
print(b-a+1)

# Fixed version:
[a,b]=map(int,input().split())
print(a-b+1)

# Buggy version:
n , k = imap ( int , input ().split())
ans = n - k + 1
print ( ans)

# Fixed version:
n,k=input().split()

n = int(n)
k = int(k)

ans = n - k + 1
print (ans)

# Buggy version:
N, K = [int(x) for x in input().split(' ')]

output = N - K + 1

# Fixed version:
N, K = [int(x) for x in input().split(' ')]

output = N - K + 1

print(int(output))

# Buggy version:
#https://atcoder.jp/contests/diverta2019/tasks/diverta2019_a
# -*- coding: utf-8 -*-

n,k = map(int,input().split())

answer = n-k+1
if n > k :
        answer = 0
print( answer )

# Fixed version:
#https://atcoder.jp/contests/diverta2019/tasks/diverta2019_a
# -*- coding: utf-8 -*-

n,k = map(int,input().split())

answer = n-k+1
if n < k :
        answer = 0
print( answer )

# Buggy version:
def combinations(N, K):
    N = int(N)
    K = int(K)
    elif N == K:
        return 1
    else:
        return N - K + 1
    
N, K = input().split(' ')

print(combinations(N, K))

# Fixed version:
def combinations(N, K):
    N = int(N)
    K = int(K)
    if N == K:
        return 1
    else:
        return N - K + 1
    
N, K = input().split(' ')

print(combinations(N, K))

# Buggy version:
import os, sys, re, math

n,k = input().split(',')
print(int(n)-int(k)+1)

# Fixed version:
import os, sys, re, math

n,k = input().split(' ')
print(int(n)-int(k)+1)

# Buggy version:
a =int(input().split())

print(a[0]-a[1]+1)

# Fixed version:
a = input().split()
print(int(a[0])-int(a[1])+1)

# Buggy version:
nk = input()

n = nk.split(' ')[0]
k = nk.split(' ')[1]

answer = n - k + 1
print(answer)

# Fixed version:
nk = input()

n = int(nk.split(' ')[0])
k = int(nk.split(' ')[1])

answer = n - k + 1
print(answer)

# Buggy version:
h = list(map(int, input().split()))



print(h[0]-h[1])

# Fixed version:
h = list(map(int, input().split()))



print(h[0]-h[1]+1)

# Buggy version:
n,k = map(int,input().split())
print(n-k-1)

# Fixed version:
n, k=map(int, input().split())
result=n-(k-1)
print(result)

# Buggy version:
N,K = map(int,input().split())
ans = K-N+1
print(ans)

# Fixed version:
N, K = map(int, input().split(" "))

ans = N - K + 1


print(ans)

# Buggy version:
n,k = [int() for i in input().split]
print(n-k+1)

# Fixed version:
n, k = [ int(i) for i in input().split()]

print(n-k+1)

# Buggy version:
A,B=map(int,input().map)
print(A-B+1)


# Fixed version:
A,B = map(int,input().split())
print(A-B+1)

# Buggy version:
N, K = [int(x) for x input().split()]

print(N - K + 1)

# Fixed version:
N,K=[int(x) for x in input().split()]
print(N-K+1)

# Buggy version:
n, k = map(int, input().split(','))
print(n-k+1)

# Fixed version:
n, k = list(map(int, input().split(' ')))
print(n - k + 1)

# Buggy version:
n,k=map(int, input().split())
print(n-k)

# Fixed version:
n,k = map(int,input().split())
print(n - (k - 1))

# Buggy version:
n,k==map(int,input().split())
print(n-k+1)

# Fixed version:
n,k,=map(int,input().split())
print(n-k+1)

# Buggy version:
a,b = map(int(input().split()))
print(a-b+1)

# Fixed version:
a, b = list(map(int, input().split()))
print(a - b + 1)

# Buggy version:
N, K = map(int, input().split())
print(K - N + 1)

# Fixed version:
N, K = map( int, input().split())
print( N-K+1)