A permutation *p* of size *n* is an array such that every integer from 1 to *n* occurs exactly once in this array.

Let's call a permutation an almost identity permutation iff there exist at least *n* - *k* indices *i* (1 ≤ *i* ≤ *n*) such that *p*<sub class="lower-index">*i*</sub> = *i*.

Your task is to count the number of almost identity permutations for given numbers *n* and *k*.
The first line contains two integers *n* and *k* (4 ≤ *n* ≤ 1000, 1 ≤ *k* ≤ 4).
none
4 1
1
4 2
7
5 3
31
5 4
76
200 1
1
200 2
19901
200 3
2646701
200 4
584811251
400 1
1
400 2
79801
400 3
21253401
400 4
9477912501
600 1
1
600 2
179701
600 3
71820101
600 4
48187303751
800 1
1
800 2
319601
800 3
170346801
800 4
152620985001
1000 1
1
1000 2
499501
1000 3
332833501
1000 4
373086956251
4 4
24
import sys
input = sys.stdin.readline
inf = float('inf')
def arr_in():
    return list(map(int, input().split()))

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

"""
--- Notes ---
- k >= 1:
+1
- k >= 2:
transpositions:
n choose 2
- k >= 3:
1 2 3

3 1 2
2 3 1
n choose 3 * 2?
- k >= 4:
1 2 3 4

2 3 4 1
3 4 1 2
4 1 2 3
2 1 4 3
4 3 2 1
"""

def solution():
    n, k = tup_in()
    ans = 0
    if k >= 1:
        ans += 1
    if k >= 2:
        ans += (n * (n - 1)) // 2
    if k >= 3:
        ans += (2 * n * (n - 1) * (n - 2)) // 6
    if k >= 4:
        ans += (9 * n * (n - 1) * (n - 2) * (n - 3)) // 24
    print(ans)


if __name__ == "__main__":
    solution()