Problem:
 Score : 100 points    Problem Statement Snuke has N integers: 1,2,\ldots,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 \leq K \leq N \leq 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

Solution (Python):
n, k = map(int, input().split())
print(n - k + 1)

Solution (Python):

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

Solution (Python):
N, K = map(int,input().split())
print(N - K + 1)

Solution (Python):
a,b=map(int,input().split());print(a-b+1)

Solution (Python):
n,k=map(int, input().split())
print(n-k+1)

Solution (Python):
s = input().split()
print(int(s[0])-int(s[1])+1)

Solution (Python):
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

if __name__ == '__main__':
    a = [int(i) for i in input().split()]
    
    print(a[0]-a[1]+1)

Solution (Python):

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


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



if __name__ == '__main__':
    solve()

Solution (Python):
n,k = map(int,input().split())
print(n-k+1)

Solution (Python):

def inputlist(): return [int(j) for j in input().split()]
from collections import Counter


N,K = inputlist()
print(N-K+1)

Solution (Python):
N, K = map(int,input().split())

print(N-K+1)

Solution (Python):
N,K=map(int,input().split())
print(N-K+1)

Solution (Python):
a,b = map(int,input().split())
print(a-b+1)

Solution (Python):
a,b = map(int,input().split())
print(a-b+1)

Solution (Python):
n, k = map(int, input().split())
print(n-k+1)

Solution (Python):
N, K = map(int, input().split())

print(N - (K-1))

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')
 

def ii(): return int(sys.stdin.readline().rstrip()) 
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) 
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]

def ss(): return sys.stdin.readline().rstrip() 
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) 
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]






ans=0
n,k=mii()

def cmb(n,r):
    r = min(n-r,r)
    if r == 0: return 1
    over = reduce(mul, range(n, n - r, -1))
    under = reduce(mul, range(1,r + 1))
    return over // under

print(n-k+1)

Solution (Python):
n, k = map(int, input().split())

print(n - k + 1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):
n, k = map(int, input().split())
print(n - k + 1)

Solution (Python):
n, k = map(int, input().split())

print(n - k + 1)

Solution (Python):
N,K=map(int,input().split())
print(N-K+1)

Solution (Python):
N,K=map(int,input().split())
print(N-K+1)

Solution (Python):
n, k = map(int, input().split())
print(n-k+1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
def main():
    n, length = map(int, input().split())
    print(n - length + 1)


if __name__ == '__main__':
    main()

Solution (Python):
n, k = map(int, input().split())

ans = n - k + 1
print(ans)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
N,K = map(int,input().split())
print(N-K+1)

Solution (Python):
n, k = map(int, input().split())
print(n-k+1)

Solution (Python):
x=list(map(int, input().split()))
print(x[0]-x[1]+1)

Solution (Python):
def main():
    n, k = map(int, input().split())
    print(n-k+1)

if __name__ == "__main__":
    main()

Solution (Python):
import sys
n, k =[int(i) for i in sys.stdin.readline().split()]
print(n - k + 1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):









import sys



ipti = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)

def main():
    n, k = list(map(int,ipti().split()))
    print(n-k+1)

if __name__ == '__main__':
    main()

Solution (Python):
a,b = map(int,input().split())
print(a - b + 1)

Solution (Python):
a, b = map(int, input().split())
print(a - b + 1)

Solution (Python):
N,K=map(int,input().split())
print(N-K+1)

Solution (Python):
n,k = map(int,input().split())
if n==k:
    print(1)
else:
    print(n-k+1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):
n,k= map(int, input().split())
print(n-k+1)

Solution (Python):
n, k = map(int, input().split())
print(n-k+1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):
N,K=map(int,input().split())
print(N-K+1)

Solution (Python):
n, k = map(int, input().split())

print(n - k + 1)

Solution (Python):


n, k = [int(x) for x in input().split()]
print(n - k + 1)

Solution (Python):
n, k = map(int, input().split())

print(n-k+1)

Solution (Python):


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

print(N - K + 1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):

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

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
N,K = map(int,input().split())
print(N - K + 1)

Solution (Python):
from sys import stdin
N, K = [int(_) for _ in stdin.readline().rstrip().split()]
print(N-K+1)

Solution (Python):
N,K = map(int,input().split())
print(N-K+1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
N,K = map(int, input().split())
print(N-K+1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
N, K = map(int, input().split())
print(N - K + 1)

Solution (Python):
N,K=map(int,input().split())
kouho=[i for i in range(1,N+1)]
count = 0
i=0
while i+K<=N:
    count +=1
    i+=1

print(count)

Solution (Python):
n,k=map(int,input().split())
print(n-(k-1))

Solution (Python):


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


print(n-k+1)

Solution (Python):
N, K = list(map(int, input().split()))
print(N-K+1)

Solution (Python):
n, k = map(int, input().split())

print(n-(k-1))

Solution (Python):
a,b=list(map(int, input().split()))
print(a-b+1)

Solution (Python):
a,b=map(int,input().split(" "))
print(max(0,a-b+1))

Solution (Python):

 
import math
import itertools
import sys
import copy
 






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

print (N-K+1)

Solution (Python):
n, k = map(int, input().split())
print(n-k+1)

Solution (Python):

import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1

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

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
def main():
    N,K = map(int,input().split())
    print(N+1-K)
if __name__ == '__main__':
    main()

Solution (Python):
from sys import stdin

a,b = [int(x) for x in stdin.readline().rstrip().split()]

print(a-b+1)

Solution (Python):
a,b=map(int,input().split())
print(a-b+1)

Solution (Python):
n,k = map(int,input().split())
print(n-k+1)

Solution (Python):
N, K = map(int, input().split())

print(N-K+1)

Solution (Python):
N,K=map(int,input().split())
print(N-K+1)

Solution (Python):
n, k = map(int, input().split())
print(n-k+1)

Solution (Python):
a,b = map(int,input().split())
print(a-b+1)

Solution (Python):
a, b = map(int, input().split())


cnt = 0
for i in range(a):
    for j in range(i, a):
        if j - i + 1 == b:
            cnt += 1

print(cnt)

Solution (Python):
a, b = map(int, input().split())
print(a-b+1)

Solution (Python):
n,k = map(int,input().split())

print(n-k+1)

Solution (Python):
n,k=map(int,input().split())

print(n-k+1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):
N,K = map(int,input().split())
print(N-K+1)

Solution (Python):
a = list(map(int,input().split()))
N=a[0]
K=a[1]

print(N-K+1)

Solution (Python):
N, K = map(int, input().split())
print(N - K + 1)

Solution (Python):
n,k=map(int,input().split())

print(n-k+1)

Solution (Python):
N,K = map(int,input().split())
print(N-K+1)

Solution (Python):
a, b = map(int, input().split())

print(a-b+1)

Solution (Python):
N, K = map(int, input().split())
print(N - K + 1)

Solution (Python):
N, K = map(int, input().split())

print(N - K + 1)

Solution (Python):
N, K = map(int, input().split())
print(N - K + 1)

Solution (Python):
N, K = map(int, input().split())

print(N - K + 1)

Solution (Python):
def main(n: int, k: int):
    print(n - k + 1)


if __name__ == "__main__":
    n, k = map(int, input().split())

    main(n, k)

Solution (Python):
import sys


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    n, k = list(map(int, readline().split()))
    print(n - k + 1)


if __name__ == '__main__':
    solve()

Solution (Python):
N,K = map(int,input().split())
print(N-K+1)

Solution (Python):

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

Solution (Python):
n, k = map(int, input().split())

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

Solution (Python):
N,K=map(int,input().split())
print(N-K+1)

Solution (Python):

N,K = map(int, input().split())
print(N-K+1)

Solution (Python):
n, k = map(int, input().split())
print(n - k + 1)

Solution (Python):
N,K = (int(i) for i in input().split())

ans = N - K + 1
print(ans)

Solution (Python):
a,b = map(int, input().split())
print(a-b+1)

Solution (Python):
N, K = map(int, input().split())
print(N - K + 1)

Solution (Python):
N, K = map(int, input().split())
print(N + 1 - K)

Solution (Python):
n,k = map(int, input().split())
print(n-k+1)

Solution (Python):

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

print (N-K+1)

Solution (Python):
n,k=map(int,input().split())
print(max(0,n-k+1))

Solution (Python):
n, k = map(int, input().split())
print(n-k+1)

Solution (Python):
n,k = map(int,input().split())
print(n-k+1)

Solution (Python):
N, K = map(int,input().split())
print(N-(K-1))

Solution (Python):
n, k = map(int, input().split())
print(n-k+1)

Solution (Python):

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

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
N, K = map(int, input().split())
print(N - K + 1)

Solution (Python):
n, k = map(int, input().split())

print(n-k+1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
n,k=map(int,input().split())

print(n-k+1)

Solution (Python):
N, K = map(int, input().split())

print(N - K + 1)

Solution (Python):
n,k = map(int, input().split())
print(n-k+1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
N,K=map(int,input().split())
print(N+1-K)

Solution (Python):
n, k = map(int, input().split())
print(n-k+1)

Solution (Python):
n, k = map(int, input().split())
print(n-k+1)

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    n, k = list(map(int, input().rstrip('\n').split()))
    print(n - k + 1)


if __name__ == '__main__':
    slove()

Solution (Python):
N, K = map(int, input().split())
print(N - K + 1)

Solution (Python):
n , k = map(int , input().split())
print(n - k + 1)

Solution (Python):
N, K = map(int,input().split())
print(N-K+1)

Solution (Python):
N, K = tuple(map(int, input().split()))
print(N - K + 1)

Solution (Python):
N, K = map(int,input().split())
print(N-K+1)

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    n, k = list(map(int, input().rstrip('\n').split()))
    print(n - k + 1)


if __name__ == '__main__':
    slove()

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
a=list(map(int,input().split()))
print(a[0]-a[1]+1)

Solution (Python):
a,b = map(int, input().split())
print(a-b+1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
n,k = map(int, input().split())
print(n-k+1)

Solution (Python):
N,K=map(int,input().split())
print(N-K+1)

Solution (Python):
n,k = map(int,input().split())
print(n-k+1)

Solution (Python):
import sys
input = sys.stdin.readline
 
def main():
    N, K = map(int, input().split())
    print(N-K+1)

if __name__ == '__main__':
    main()

Solution (Python):
N, K = map(int, input().split())
r = N-K++1
print(r)

Solution (Python):

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

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
n,k = map(int,input().split())
print(n-k+1)

Solution (Python):
n, k = map(int, input().split())
print(n - k + 1)

Solution (Python):
a,b = map(int,input().split())
print(a-b + 1)

Solution (Python):



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




print(N - (K - 1))

Solution (Python):
N, K = map(int, input().split())
print(N+1-K)

Solution (Python):
n, k = map(int, input().split())
print(n-k+1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):
n, k = map(int,input().split())
print(n - (k-1))

Solution (Python):
N, K = [int(_) for _ in input().split()]

print(N - K + 1)

Solution (Python):
n, k = map(int, input().split())
print(n - k + 1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
N, K = map(int, input().split())

print (N - K + 1)

Solution (Python):
N,K=map(int,input().split())
print(N-K+1)

Solution (Python):
N, K = map(int, input().split())
ans = N - K + 1
print(ans)

Solution (Python):
a,b = map(int,input().split(" "))
print((a - b) + 1)

Solution (Python):
def solve(n, k):
    return n - k + 1

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

Solution (Python):
n,k = map(int,input().split())
print(n-k+1)

Solution (Python):
a,b = map(int, input().split())
print(a-b+1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):
n, k = map(int, input().split())
print(n-k+1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):
N, K = map(int, input().split())
print(N - K + 1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

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

Solution (Python):
N, K = map(int, input().split())

print(N - K + 1)

Solution (Python):
N, K = map(int,input().split())
print(N - K + 1)

Solution (Python):
N,K = map(int,input().split())

print(N-K+1)

Solution (Python):
n,k = map(int,input().split())
print(n-k+1)

Solution (Python):
n, k = map(int, input().split())
Answer = n - k + 1
print(Answer)

Solution (Python):
N, K = map(int, input().split())

print(N-K+1)

Solution (Python):
n,k = map(int,input().split())
print(n-k+1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):
N, K = map(int, input().split())
ans = N -K + 1
print(ans)

Solution (Python):
N, M = map(int, input().split())
ans = N-M+1
print(ans)

Solution (Python):




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


'''
for i in range h:
    temp = list(map(int, input().split()))
    table.append(temp)
'''
print(n-k+1)

Solution (Python):
n,k = map(int,input().split())
a = 0
for i in range(1,n+1):
    if i+k - 1 <= n:
        a += 1
    else:
        a += 0
print(a)

Solution (Python):
n, m = list(map(int, input().split()))
print(n-m+1)

Solution (Python):

import sys


def solve(N: int, K: int):
    print(N-K+1)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    K = int(next(tokens))  
    solve(N, K)

if __name__ == '__main__':
    main()

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LS()
    return l
sys.setrecursionlimit(1000000)
mod = 1000000007


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


def B():
    n = I()

    return


def C():
    n = I()

    return


def D():
    n = I()

    return


def E():
    n = I()

    return


def F():
    n = I()

    return


def G():
    n = I()

    return


def H():
    n = I()

    return


def I_():
    n = I()

    return


def J():
    n = I()

    return


if __name__ == "__main__":
    A()

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):
N, K = map(int, input().split())

ans = 0

for i in range(N):
  if i+K <= N:
    ans += 1
  else:
    break

print(ans)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
N,K=map(int,input().split())

print(N-(K-1))

Solution (Python):
n, r = map(int,input().split())
print(n-r+1)

Solution (Python):
n,k=map(int,input().split())

print(n-k+1)

Solution (Python):




import math
import statistics

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

Solution (Python):
a,b=map(int,input().split())
c=a-b+1
print(c)

Solution (Python):
N,K = list(map(int,input().split(' ')))
print(N-K+1)

Solution (Python):
n, k = map(int, input().split())
print(n - k + 1)

Solution (Python):
N, K = map(int, input().split(" "))
print(N - K + 1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):
list = [int(x) for x in input().split()]
print(list[0] - list[1] + 1)

Solution (Python):
N,K = map(int,input().split())
print(N-K+1)

Solution (Python):
N,K=map(int,input().split())
print(N+1-K)

Solution (Python):

a, b = map(int, input().split())
print(a - b + 1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):
a,b=map(int,input().split())
print(a-b+1)

Solution (Python):
n, k = [ int(v) for v in input().split() ]
print(n-k+1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
n,m=map(int,input().split())
print(n-m+1)

Solution (Python):
N,K = map(int,input().split())
print(N-K+1)

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

Solution (Python):
n, k = map(int, input().split())
print(n-k+1)

Solution (Python):

nl = lambda: list(map(int, input().split()))
sl = lambda: input().split()
n = lambda: int(input())
s = lambda: input()

N, K = nl()
print(N-K+1)

Solution (Python):


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

print n-(k-1)

Solution (Python):


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

print n-(k-1)

Solution (Python):
n, k = map(int, input().split())
print(n-k+1)

Solution (Python):
n, k = map(int, input().split())

print(n - k + 1)

Solution (Python):
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


def ceil(a, b):
    return (a + b - 1) // b



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



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


def main():
    N, K = map(int, input().split())
    print(N - K + 1)


if __name__ == '__main__':
    main()

Solution (Python):
n,m=map(int,input().split())
ans=n-m+1
print(ans)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):
n,k = map(int,input().split())
print(n-k+1)

Solution (Python):
a,b=map(int, input().split())
print(a-b+1)

Solution (Python):
hoge = input().split()
n = int(hoge[0])
k = int(hoge[1])
print(n-k+1)

Solution (Python):
N, K = map(int,input().split())

print(N + 1 - K)

Solution (Python):
a,b=map(int,input().split())
print(a-b+1)

Solution (Python):
n, k = map(int, input().split())
print(n-k+1)

Solution (Python):
N, K = map(int, input().split())

print(N-K+1)

Solution (Python):
n, k = tuple(int(x) for x in raw_input().split(' '))
print(n - k + 1)

Solution (Python):
N, K = map(int, input().split())
print(N - K + 1)

Solution (Python):
N, K = list(map(int, input().split()))
print(N - K + 1)

Solution (Python):
N,K = map(int,input().split())
print(N-K+1)

Solution (Python):

"""
A - Consecutive Integers
https://atcoder.jp/contests/diverta2019/tasks/diverta2019_a

"""
import sys


def solve(N, K):
    return N-K+1


def main(args):
    N, K = map(int, input().split())
    ans = solve(N, K)
    print(ans)


if __name__ == '__main__':
    main(sys.argv[1:])

Solution (Python):

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

Solution (Python):


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

print(N-K+1)

Solution (Python):
n, k = [int(x) for x in input().rstrip().split(" ")]

print(n - (k - 1))

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
from collections import defaultdict
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, input().split()))
def inpl_str(): return list(input().split())

N,K = inpl()
print(N-K+1)

Solution (Python):
N,K=map(int,input().split())
print(N-K+1)

Solution (Python):
N,K = map(int,input().split())
print(N-K+1)

Solution (Python):
N,K = map(int,input().split())
print(N-K+1)

Solution (Python):
N,K = map(int,input().split())
print(N - K + 1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

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

Solution (Python):
N, K = map(int, input().split())

ans = N - (K-1)
print(ans)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):
N, K = map(int, input().split())
print(N - K + 1)

Solution (Python):
N, K = map(int, input().split())
print(N - K + 1)

Solution (Python):
n,k =map(int,input().split())

print(n-k+1)

Solution (Python):
a,b = map(int,input().split())
print(a - b + 1)

Solution (Python):
n,k=map(int, input().split())
print (n-(k-1))

Solution (Python):
from sys import exit

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

print(N - K + 1)

Solution (Python):
n, k = map(int, input().split())
print(n - k + 1)

Solution (Python):
n, k = map(int, input().split())
print(n - k + 1)

Solution (Python):
n, k = map(int, input().split())
print(n - k + 1)

Solution (Python):
n, k = map(int, input().split())
print(n - k + 1)

Solution (Python):
N,K=map(int,input().split())
print(N-(K-1))

Solution (Python):
N,M = map(int,input().split())
print(N - M + 1)

Solution (Python):
N,K = list(map(int,input().split()))
print(N-K+1)

Solution (Python):
N,M = map(int,input().split())
print(N - M + 1)

Solution (Python):
N, K = map(int, input().split())
A = N - K + 1
print(A)

Solution (Python):
a = list(map(int,input().split()))
print(a[0] - a[1] + 1)

Solution (Python):
a = list(map(int,input().split()))
print(a[0]-a[1]+1)

Solution (Python):
n, k = map(int, raw_input().split())



print n-k +1

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
import sys,heapq
from collections import deque,defaultdict
printn = lambda x: sys.stdout.write(x)
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
DBG = True 
def ddprint(x):
  if DBG:
    print(x)

n,k = inm()
print(n-k+1)

Solution (Python):
n, k = map(int, input().split())
print(n-k+1)

Solution (Python):
n,k=map(int,input().split())
if 1<=k<=n<=50:
    print(n+1-k)

Solution (Python):
n, k = map(int, raw_input().strip().split())
print n - k + 1

Solution (Python):
n, k = map(int, input().split())
print(n - k + 1)

Solution (Python):
n,k=list(map(int,input().split()))
if 1<=k<=n<=50:
	print(n+1-k)

Solution (Python):
n,k=[int(x) for x in input().split()]
print(n+1-k)

Solution (Python):
import numpy as np


l = list(map(int, input().split()))
A = l[0] 
B = l[1] 

print( A - (B-1) )

Solution (Python):
n,k=map(int,input().split())
l=[i for i in range(1,n+1)]
ans=[]
for i in range(n-k+1):
    ans+=[l[i:k+i]]
print(len(ans))

Solution (Python):
n,k=map(int,input().split())
print(n-(k-1))

Solution (Python):
N,M=list(map(int,input().split()))
print(N-M+1)

Solution (Python):


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

ans = N - (K - 1)

print (ans)

Solution (Python):
'''input
3 2
'''

N, K=map(int, input().split())
print(N-K+1)

Solution (Python):
N,K = map(int, input().split())
print(N - K + 1)

Solution (Python):
N,K=map(int,input().split())

print(N-(K-1))

Solution (Python):
N, K = map(int, input().split())

print(N-K+1)

Solution (Python):
N, K = list(map(int, input().split()))

print(N - K + 1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):
import sys

def main(inp):
    n,k = map(int,next(inp).split())
    return n-k+1
  
print(main(sys.stdin))

Solution (Python):
N, K = map(int, input().strip().split())
print(N-K+1)

Solution (Python):
N, K = list(map(int, input().split()))

print(N - K + 1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
N, K = list(map(int,input().split()))
print(N-K+1)

Solution (Python):
read = input
n, k = map(int, read().split())
print(n-k+1)

Solution (Python):
n, k = map(int, input().split())
print(n - k + 1)

Solution (Python):
n, k = map(int, input().split())
print(n - k + 1)

Solution (Python):
n, k = map(int, raw_input().split())
print n-k+1

Solution (Python):

n, k = list(map(int, input().rstrip().split()))
print(n - k + 1)

Solution (Python):
n, k = map(int, raw_input().split(" "))
print("%d" % (n - k + 1))

Solution (Python):
N,K = [int(x) for x in input().split(' ')]
ans = N - (K-1)
print(ans)

Solution (Python):
N, K = map(int, input().split())
print(N - K + 1)

Solution (Python):
N, K = map(int, input().split())
print(N - (K - 1))

Solution (Python):
input_list = [int(i) for i in input().split()] 
print(input_list[0] - input_list[1] + 1)

Solution (Python):
a, b=list(map(int, input().split()))
print(a-b+1)

Solution (Python):
n, k = list(map(int, input().split()))
print(n-k+1)

Solution (Python):
n,m = map(int,input().split())
print(n-m+1)

Solution (Python):
N,K = map(int,input().split())
print(N - K + 1)

Solution (Python):
N, K = map(int, input().split())

print(N - K + 1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):

import numpy as np
import math
import statistics as sta



def main():
    num=list(map(int,input().split()))
    ans=num[0]-num[1]+1
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
N, K = map(int, input().split())
answer = N - K + 1
print(answer)

Solution (Python):


l = list(map(int, input().split()))

N = l[0]
K = l[1]

print(N - K + 1)

Solution (Python):
print(eval(input().replace(" ","+1-")))

Solution (Python):
IN1 = input().split()
N = int(IN1[0])
K = int(IN1[1])
print(N - K + 1)

Solution (Python):
n,k = map(int,input().split())

print(n-k+1)

Solution (Python):
[a,b]=map(int,input().split())
print(a-b+1)

Solution (Python):
def solve():
  n,k = (int(i) for i in input().split())
  print(n-k+1)
solve()

Solution (Python):
A,B=map(int,input().split())
c=A-B+1
print(c)

Solution (Python):
N,K=map(int,input().split())
print(N-K+1)

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()

mi = lambda: map(int, input().split())

M, N = mi()

print(M-N+1)

Solution (Python):
n=input().split()
n[0]=int(n[0])
n[1]=int(n[1])
answer=n[0]-n[1]+1
if answer<=0:
    print("0")
else:
    print(answer)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
n,k = map(int, input().split())
print(n-k+1)

Solution (Python):
n, k = map(int, input().split())

print(n - k + 1)

Solution (Python):
N, K = map(int, input().split())

print(N-K+1)

Solution (Python):
N, K =(int(x) for x in input().split())
print (N-K+1)

Solution (Python):
n,k = (int(x) for x in input().split())
print(str(n - k + 1))

Solution (Python):
N,K = map(int,input().split(" "))
ans = N - K + 1
print(ans)

Solution (Python):

inputdata=input().split()
n=int(inputdata[0])
k=int(inputdata[1])
pointer=1
while pointer +k <= n:
  pointer = pointer +1

if n < k:
  print("0")
else:
  print(pointer)

Solution (Python):
n,k = map(int,input().split())
print(n-k+1)

Solution (Python):


import sys

input = sys.stdin.readline
n, k = map(int, (input().split()))
print(n - k + 1)

Solution (Python):
def main():
    N, K = map(int, input().split())
    ans = N - K + 1
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
n,k=map(int,input().split())
print(n+1-k)

Solution (Python):
[n,k]=map(int,raw_input().split())
print max(0,n-k+1)

Solution (Python):
n,k=map(int,input().split());print(n-k+1)

Solution (Python):
n, k = map(int, input().split())
print(n-k+1)

Solution (Python):
n,k=map(int,input().split());print(n-k+1)

Solution (Python):
n, k = map(int, input().split())

print(n - k + 1)

Solution (Python):
N, K = map(int, input().split())
print(str(N - K + 1))

Solution (Python):
n,k = map(int,input().split())

print(n-k+1)

Solution (Python):
n, k = map(int, input().split())
print(n - (k - 1))

Solution (Python):
n, k = map(int, input().split())
print(n - k + 1)

Solution (Python):
N , K = map(int , input().split())

print(N-(K-1))

Solution (Python):
N,K = map(int,input().split())
print(N-K+1)