qyliang/CodeNanoFix huggingface dataset:
Buggy code:
s = str(s)
list_ans.append("KIHBR")
list_ans.append("AKIHBR")
list_ans.append("KIHABR")
list_ans.append("KIHBAR")
list_ans.append("KIHBRA")
list_ans.append("AKIHABR")
list_ans.append("AKIHBAR")
list_ans.append("AKIHBRA")
list_ans.append("KIHABAR")
list_ans.append("KIHABRA")
list_ans.append("KIHBARA")
list_ans.append("AKIHABAR")
list_ans.append("AKIHABRA")
list_ans.append("AKIHBARA")
list_ans.append("KIHABARA")
list_ans.append("AKIHABARA")
if s in list_ans:
    print("YES")
else:
    print("NO")

Fixed code:

s = str(input())
list_ans = []
list_ans.append("KIHBR")
list_ans.append("AKIHBR")
list_ans.append("KIHABR")
list_ans.append("KIHBAR")
list_ans.append("KIHBRA")
list_ans.append("AKIHABR")
list_ans.append("AKIHBAR")
list_ans.append("AKIHBRA")
list_ans.append("KIHABAR")
list_ans.append("KIHABRA")
list_ans.append("KIHBARA")
list_ans.append("AKIHABAR")
list_ans.append("AKIHABRA")
list_ans.append("AKIHBARA")
list_ans.append("KIHABARA")
list_ans.append("AKIHABARA")
if s in list_ans:
    print("YES")
else:
    print("NO")
Buggy code:
n, m = map(int, (input().split()))
resp = (n*(n-1))/2 + (m*(m-1))/2
print(resp)

Fixed code:
n, m = map(int, input().split())

print((n*(n-1))//2 + (m*(m-1))//2)
Buggy code:
import math

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

ans = n*(n-1)//2 + m(m-1)//2
print(ans)


Fixed code:
n,m = map(int, input().split())

ans = n*(n-1) // 2 + m*(m-1)//2

print(ans)
Buggy code:
N,M=map(int,input().split())
gg=N*(N-1)/2
kk=M*(M-1)/2
print(gg+kk)

Fixed code:
N,M=map(int,input().split())
gg=N*(N-1)//2
kk=M*(M-1)//2
print(gg+kk)
Buggy code:
n, m = map(int, input().split())

ans = n * (n - 1) / 2 + m * (m - 1) / 2

print(ans)

Fixed code:
n,m=map(int,input().split())

print(int(n*(n-1)/2+m*(m-1)/2))
Buggy code:
N, M = map(int, input().split())
print(int(N * (N - 1) + M * (M-1)) / 2)


Fixed code:
N,M=map(int,input().split(' '))
print(N*(N-1)//2+M*(M-1)//2)
Buggy code:
nm = input()
n = int(nm[0])
m = int(nm[1])

ans = 0

n1 = n*(n-1)/2

n2 = m*(m-1)/2

ans = n1 + n2

print(ans)

Fixed code:
nm = input().split()
n = int(nm[0])
m = int(nm[1])

ans = 0

n1 = n*(n-1)/2

n2 = m*(m-1)/2

ans = int(n1 + n2)

print(ans)
Buggy code:
N,M = map(int,input().split())
# ue,sita,uee,sitaa = 0,0,0,0
# tmpN,tmpM = 0,0
# if N != 2:
#     for i in range(N+1):
#         ue *= N-i
#         sita *= N-2-i
#     tmpN = ue/sita
# if M != 2:
#     for i in range(M+1):
#         uee *= N-i
#         sitaa *= N-2-i
#     tmpM = uee/sitaa

# print(tmpN+tmpM)

ans = N/2 + M/2
print(int(ans))

Fixed code:
N,M = map(int,input().split())
# ue,sita,uee,sitaa = 0,0,0,0
# tmpN,tmpM = 0,0
# if N != 2:
#     for i in range(N+1):
#         ue *= N-i
#         sita *= N-2-i
#     tmpN = ue/sita
# if M != 2:
#     for i in range(M+1):
#         uee *= N-i
#         sitaa *= N-2-i
#     tmpM = uee/sitaa

# print(tmpN+tmpM)

ans = N*(N-1)/2 + M*(M-1)/2

print(int(ans))
Buggy code:
N, M = map(int, input().split(' '))

cnt = (N*(N-1))/2 + (M*(M-1))/2

print(cnt)

Fixed code:
N, M = map(int, input().split(' '))
 
cnt = (N*(N-1))//2 + (M*(M-1))//2
 
print(cnt)
Buggy code:
n,m=map(int,input().split())
x=n*(n-1)/2+m*(m-1)/2
print(x)

Fixed code:
n, m = map(int,input().split())
print(int((n * (n - 1) / 2) + (m * ( m - 1) / 2)))
Buggy code:
N,M=map(int, input().split())
A=N*(N-1)/2
B=M*(M-1)/2
print(A+B)


Fixed code:
N,M=map(int, input().split())
A=N*(N-1)/2
B=M*(M-1)/2
print(int(A+B))
Buggy code:
x,y = map(int,input().split())	

# even + even 
ans = x*(x – 1) / 2

# odd + odd
ans += y*(y-1) / 2

print(ans)


Fixed code:
x,y = map(int,input().split())

# even + even
ans = x*(x-1) / 2

# odd + odd
ans += y*(y-1) / 2

print(int(ans))
Buggy code:
n, m = [int(x) for x in input().split()]
print(((n*(n-1))/2)+((m*(m-1))/2))

Fixed code:
n, m = [int(i) for i in input().split()]
print(n*(n-1)//2+m*(m-1)//2)
Buggy code:
n,m = input().split()
n=int(n)
m=int(m)

nout =n* (n-1)/2
mout =m* (m-1)/2

print(nout+mout)

Fixed code:
n,m = input().split()
n=int(n)
m=int(m)

nout =n* (n-1)//2
mout =m* (m-1)//2

print(nout+mout)
Buggy code:
N, M = (int(x) for x in input().split())
A = N * (N-1)/2 + M*(M-1)/2
print(A)

Fixed code:
N, M = (int(x) for x in input().split())
A = N * (N - 1) / 2
B = M * (M - 1) / 2
print(int(A+B))
Buggy code:
I = input().split()

N = int(I[0])
M = int(I[1])

print( N*(N-1)/2 + M*(M-1)/2 )


Fixed code:
I = input().split()

N = int(I[0])
M = int(I[1])

print( int(N*(N-1)/2) + int(M*(M-1)/2) )
Buggy code:
N, M = map(int, input().split())
print((N*(N-1)/2) + (M*(M-1)/2))

Fixed code:
N, M = list(map(int, input().split()))
print(int((N * (N-1) / 2) + (M * (M-1)/2)))
Buggy code:
n ,m = map(int,input().split())

print(n*(n-1)/2 + m*(m-1)/2)


Fixed code:
n,m = map(int,input().split())

print(n * (n - 1)//2 + m * (m - 1)//2)
Buggy code:
a, b = map(int, input().split(' ')
print(a*(a-1)/2 + b*(b-1)/2)

Fixed code:
a, b = map(int, input().split(' '))
print(int(a*(a-1)/2 + b*(b-1)/2))
Buggy code:
n,m=map(int,input().split())
print((n*(n-1)+m*(m-1))/2)

Fixed code:
n,m=map(int,input().split())
print((n*(n-1)+m*(m-1))//2)
Buggy code:
N, M = map(int, input().split())

print( (N * (N-1)) / 2 + (M * (M-1)) /2)

Fixed code:
N,M = map(int,input().split())
ans = int((N*(N-1)+M*(M-1))/ 2)
print(ans)
Buggy code:
N, M = map(int,input().split()))
a = (N*(N-1))/2
b = (M*(M-1))/2
print(a+b

Fixed code:
N, M = map(int,input().split())
a = (N*(N-1))/2
b = (M*(M-1))/2
print(int(a+b))
Buggy code:
a = input().split(' ')
b = (a[0] * a[0]-1)/2 + (a[1] * a[1]-1)/2
print (b)

Fixed code:
a = input().split(' ')
b = (int(a[0]) * (int(a[0])-1))/2 + (int(a[1]) * (int(a[1])-1))/2
print(int(b))
Buggy code:
N,M=input().split()
n=int(N)
m=int(M)
a=n*(n-1)
b=m*(m-1)
print(a+b)

Fixed code:
N,M=input().split()
n=int(N)
m=int(M)
a=int((n*(n-1))/2)
b=int((m*(m-1))/2)
print(a+b)
Buggy code:
n,m = map(int, input().split())

print(n*(n-1)/2+m*(m-1)/2)

Fixed code:
n, m = map(int, input().split())

print(n * (n - 1) // 2 + m * (m - 1) // 2)
Buggy code:
import sys

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

def com(n,r):
    ans1 = 1
    ans2 = 1
    tmp = r
    while r != 0:
        ans1 = ans1 * (n)
        ans2 = ans2 * r
        n -= 1
        r -= 1

    return ans1/ans2

print(com(N,2)+com(M,2))


Fixed code:
import sys

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

def com(n,r):
    ans1 = 1
    ans2 = 1
    tmp = r
    while r != 0:
        ans1 = ans1 * (n)
        ans2 = ans2 * r
        n -= 1
        r -= 1

    return ans1/ans2

print(int(com(N,2)+com(M,2)))
Buggy code:
import math
n,m = map(int,input().split())
n2 = n*(n-1)/2
m2 = m*(m-1)/2

print((n2+m2)//1)

Fixed code:
import math
n,m = map(int,input().split())
n2 = n*(n-1)/2
m2 = m*(m-1)/2

print(round(n2+m2))
Buggy code:
guu, ki = map(int, input().split())

print(guu*(guu-1)/2 + ki*(ki-1)/2)

Fixed code:
guu, ki = map(int, input().split())

print(int(guu*(guu-1)/2 + ki*(ki-1)/2))
Buggy code:
#abc159 a
n,m=map(int,input().split())
ans=n*(n-1)/2+(m-1)/2
print(ans)


Fixed code:
#abc159 a
n,m=map(int,input().split())
ans=n*(n-1)/2+m*(m-1)/2
print(int(ans))
Buggy code:
M, N = map(int, input().split())

print(M*(M-1)/2+N*(N-1)/2)

Fixed code:
N, M = map(int,input().split())
print(N*(N-1)//2+M*(M-1)//2)
Buggy code:
n, m = map(int, input().split())
c = 0
c += n*(n-1)/2
c += m*(m-1)/2
print(c)

Fixed code:
n, m = map(int, input().split())
c = 0
c += int(n*(n-1)/2)
c += int(m*(m-1)/2)
print(c)
Buggy code:
n,m=map(int,input().split())

if n==1 and m==1:
  print("0")
if n==1:
  print(m/2)
if m==1:
  print(n/2)
else:
    print(n*(n-1)/2+m*(m-1)/2)

Fixed code:
n,m = map(int,input().split())
if n == 1:
    if m == 1:
        print(0)
    else:
        print(int(m*(m-1)/2))
else:
    if m == 1:
        print(int(n*(n-1)/2))
    else:
        print(int((n*(n-1)+m*(m-1))/2))
Buggy code:
a = map(int, input().split())
print(n*(n-1)//2 + m(m-1)//2)

Fixed code:
n, m = map(int, input().split())
a = n*(n-1)//2
b = m*(m-1)//2
print(a+b)
Buggy code:
n,m=map(int,input().split())
result=0
n1=1
m1=1
for i in range(n-1,n+1):
    n1*=i
for k in range(m-1,m+1):
    m1*=k
print((n1+m1)/2)

Fixed code:
n,m=map(int,input().split())
result=0
n1=1
m1=1
for i in range(n-1,n+1):
    n1*=i
for k in range(m-1,m+1):
    m1*=k
print(int((n1+m1)/2))
Buggy code:
N, M = map(int, input().split())

print(N(N - 1) // 2 + M(M - 1) // 2)


Fixed code:
N, M = map(int, input().split())


print(N * (N-1) // 2 + M * (M-1) // 2)
Buggy code:
n,m=map(int,input().split())
a=n*(n-1)/2
b=m*(m-1)/2
print(a+b)

Fixed code:
n,m=map(int,input().split())
a=round(n*(n-1)/2)
b=round(m*(m-1)/2)
print(a+b)
Buggy code:
N, M = map(int, input().split())

print((N*(N-1)+M*(M-1))/2)


Fixed code:
N, M = map(int, input().split(" "))
print(N * (N - 1) // 2 + M * (M - 1) // 2)
Buggy code:
data = input().split()
N = int(data[0])
M = int(data[1])

C = N * (N - 1) / 2 + M * (M - 1) / 2
print(C)


Fixed code:
data = input().split()
N = int(data[0])
M = int(data[1])

C = N * (N - 1) / 2 + M * (M - 1) / 2
print(int(C))
Buggy code:
n, m= map(int, input().split())
print((n+m)*(n+m-1)/2-n*m/2)

Fixed code:
n, m = map(int, input().split())
ans = n * (n - 1) // 2
ans += m * (m - 1) // 2
print(ans)
Buggy code:
if __name__ == '__main__':
    n , m = map(int, input().split())
    print(((n * n - 1) / 2 )+ ((m * m - 1)/2))

Fixed code:
def main():
    n, m = map(int, input().split())
    print(n * (n - 1) // 2 + m * (m - 1) // 2)


if __name__ == '__main__':
    main()
Buggy code:
a,b = map(int,input().split())
print(a*(a-1)/2+b*(b-1)/2)

Fixed code:
a,b = map(int,input().split())
print(a*(a-1)//2+b*(b-1)//2)
Buggy code:
def combination(M,N):
    return M*(M-1)/2+N*(N-1)/2
M,N=map (int,input().split())
x=combination(M,N)
print(x)


Fixed code:
def combination(M,N):
    return M*(M-1)/2+N*(N-1)/2
M,N=map (int,input().split())
x=combination(M,N)
x=int(x)
print(x)
Buggy code:
#! env/bin/local python3
# -*- coding: utf-8 -*-

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

pick_up_from_n = n * (n - 1) / 2
pick_up_from_m = m * (m - 1) / 2

print(pick_up_from_m + pick_up_from_n)

Fixed code:
#! env/bin/local python3
# -*- coding: utf-8 -*-

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

pick_up_from_n = n * (n - 1) // 2
pick_up_from_m = m * (m - 1) // 2

print(pick_up_from_m + pick_up_from_n)
Buggy code:
N,M = map(int,input().split())
a = N+M
b = N+M-1
print(a*b/2-N*M)

Fixed code:
N,M=map(int,input().split())
a=N
a=a*(N-1)/2
b=M*(M-1)/2



print(int(a+b))
Buggy code:
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time, copy,bisect
from operator import itemgetter
#from heapq import heappush, heappop
#import numpy as np
#from scipy.sparse.csgraph import shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson
#from scipy.sparse import csr_matrix
#from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

stdin = sys.stdin

ni = lambda: int(ns())
nf = lambda: float(ns())
na = lambda: list(map(int, stdin.readline().split()))
nb = lambda: list(map(float, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  # ignore trailing spaces

N, M = na()
print(N * (N - 1) // 2 + M)




Fixed code:
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time, copy,bisect
from operator import itemgetter
#from heapq import heappush, heappop
#import numpy as np
#from scipy.sparse.csgraph import shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson
#from scipy.sparse import csr_matrix
#from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

stdin = sys.stdin

ni = lambda: int(ns())
nf = lambda: float(ns())
na = lambda: list(map(int, stdin.readline().split()))
nb = lambda: list(map(float, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  # ignore trailing spaces

N, M = na()
print(N * (N - 1) // 2 + M * (M - 1) // 2)
Buggy code:
n,m=map(int, input().split())
print(n*(n-1)//2+m(m-1)//2)

Fixed code:
n, m = map(int, input().split())

print(int(n*(n-1)/2+m*(m-1)/2))
Buggy code:
N, M = map(int, input().split())
count = N*(N-1) // 2
count += N*M
print(count)

Fixed code:
N, M = map(int, input().split())
count = 0
count += N*(N-1) // 2
count += M*(M-1) // 2
print(count)
Buggy code:
N, M = map(int, input().split())

even = N*(N-1)/2
odd = M*(M-1)/2

ans = even + odd

print(ans)

Fixed code:
N,M = map(int, input().split())
ans = N*(N-1)//2 + M*(M-1)//2
print(ans)
Buggy code:
N, M = map(int, input().split())

even = N*(N-1)/2
odd = M*(M-1)/2

print(even + odd)

Fixed code:
N, M = map(int, input().split())

even = N*(N-1)/2
odd = M*(M-1)/2

print(int(even + odd))
Buggy code:
n, m = map (int, input().split())
ex1 = n*(n-1)/2
ex2 = m*(m-1)/2
ans = ex1 + ex2
print(ans)

Fixed code:
n, m = map (int, input().split())
ex1 = n*(n-1)//2
ex2 = m*(m-1)//2
ans = ex1 + ex2
print(ans)
Buggy code:
N,M=map(int, input().split()) 
if M == 1:
    answer = N * N-1
elif N == 1:
    answer = M * M-1
else:
    answer = (N * (N-1))//2 + (M * (M-1))//2
print(answer)

Fixed code:
N,M=map(int, input().split()) 
if M == 1 or M==0:
    answer = N * (N-1)//2
elif N == 1 or N==0:
    answer = M * (M-1)//2    
else:
    answer = (N * (N-1))//2 + (M * (M-1))//2
print(answer)
Buggy code:
n,m=map(int,input().split())
print(int((n*(n-1)/2 + m*(m-1)*2)))

Fixed code:
n,m=list(map(int,input().split()))

print(n*(n-1)//2+m*(m-1)//2)
Buggy code:
N, M = map(int, input().split())
ans = N*(N-1)/2 + M*(M-1)/2
print(ans)

Fixed code:
N,M = map(int,input().split())

print(N*(N-1)//2 + M*(M-1)//2)
Buggy code:
n, m = map(int,input().split())
print(n*(n-1)/2+m*(m-1)/2)

Fixed code:
n,m = map(int, input().split())

print(int(n * (n-1) / 2 + m * (m - 1) / 2))
Buggy code:
n,m=map(int,input().split())

print(n*(n-1)/2+m*(m-1)//2)

Fixed code:
n,m=map(int,input().split())
print(n*(n-1)//2 + m*(m-1)//2)
Buggy code:
from math import factorial

def conb2(a):
    if a == 1:
        return 0
    else:
        return int(factorial(a) / factorial(2) / factorial(a-2))


if __name__ == "__main__":
    M, N = list(map(int, input().split()))
    print(conb2(M)+conb2(N))

Fixed code:
from math import factorial

def conb2(a):
    if a == 1:
        return 0
    else:
        return int(a*(a-1)/2)


if __name__ == "__main__":
    M, N = list(map(int, input().split()))
    print(conb2(M)+conb2(N))
Buggy code:
import math
import string


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


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor


# coordinates
dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]


n, m = map(int, input().split())
#print(n, m)
if n == 1:
    print(0)
    exit()
a = nCr(n, 2)
print(a+m)


Fixed code:
import math
import string
import collections
from collections import Counter


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


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor


# coordinates
dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]


n, m = map(int, input().split())
print(n*(n-1)//2+m*(m-1)//2)
Buggy code:
N, M = map(int, input().split())
ans = 0
ans += N * (N - 1) / 2
ans += M * (M - 1) / 2
print(ans)

Fixed code:
N, M = map(int, input().split())
ans = 0
ans += (N * (N - 1)) // 2
ans += (M * (M - 1)) // 2
print(ans)
Buggy code:
N,M = map(int, input().split())
print(((N * (N - 1)) / 2 ) + ((M * (M - 1)) / 2 ))


Fixed code:
N, M = map(int, input().split())

print((N * (N-1) // 2) + (M * (M-1) // 2))
Buggy code:
n, m = map(int, input().split())
print(n*(n-1)/2 + m*(m-1)/2)

Fixed code:
n, m =map(int, input().split())

ans = n * (n-1) // 2
ans += m * (m-1) // 2

print(ans)
Buggy code:
n,m=map(int,input().split())
ans=((n*(n-1))/2)+(m*(m-1))/2
print(ans)

Fixed code:

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

print(n*(n-1)//2 + m*(m-1)//2)
Buggy code:
N, M = map(int, input().split())
ans = ((N * (N - 1)) / 2) + ((M * (M - 1)) / 2)
print(ans)

Fixed code:
N,M=map(int,input().split())
ans=((N+M)*(N+M-1)/2)-N*M
print(int(ans))
Buggy code:
N,M = map(int,input().split())
print(N*(N-1)/2+M*(M-1)/2)

Fixed code:
N, M = list(map(int, input().split()))

print(N * (N - 1) // 2 + M * (M - 1) // 2)
Buggy code:
a,b=map(int,input().split())
print(a*(a-1)//2+b(b-1)//2)

Fixed code:
a,b=map(int,input().split())
print(a*(a-1)//2+b*(b-1)//2)
Buggy code:
N,M=map(int,input().split())
print((N*(N-1)+M*(M-1))/2)

Fixed code:
N,M = map(int,input().split())

print(((N+M)*(N+M-1))//2 - (N*M))
Buggy code:
n,m=map(int,input().split())

print((n*(n-1)+m*(m-1))/2)


Fixed code:
n,m=map(int,input().split())

print(int((n*(n-1)+m*(m-1))/2))
Buggy code:
n,m = map(int,input().split())
print(n*(n-1)/2 + m*(m-1)/2)


Fixed code:
n,m = map(int,input().split())
print(n*(n-1) // 2 + m*(m-1) // 2)
Buggy code:
N,M=map(int,input().split())
print((N**2-N)/2 + (M**2-M)/2)

Fixed code:
N,M=map(int,input().split())
Ans = (N**2-N)/2 + (M**2-M)/2
print(int(Ans))
Buggy code:
N, M = map(int, input().split())

X = (N * (N-1) / 2) + (M * (M-1) / 2)

print(X)

Fixed code:
N, M = map(int, input().split())

X = int((N * (N-1) / 2) + (M * (M-1) / 2))

print(X)
Buggy code:
N, M = map(int, input().split())
ans = N*(N-1)/2 + M*(M-1)/2
print(ans)


Fixed code:
N, M = map(int, input().split())
ans = N*(N-1)/2 + M*(M-1)/2
print(int(ans))
Buggy code:
n,w=map(int,input().split())
print(n*w(n*w-1) /2)

Fixed code:
n,w=map(int,input().split())
print((n*(n-1)//2)+(w*(w-1)//2))
Buggy code:
import math

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

sum = (N*(N-1))/2 + (M*(M-1))/2
print(sum)

Fixed code:

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

sum = (N*(N-1))/2 + (M*(M-1))/2
print(int(sum))
Buggy code:
i = list(map(int, input().split()))

n = int(i[0])
m = int(i[1])

p = (m+n)*(m+n-1)/2 - (m*n)

print(p)

Fixed code:
i = list(map(int, input().split()))

n = int(i[0])
m = int(i[1])

p = (m+n)*(m+n-1)/2 - (m*n)

print(int(p))
Buggy code:
a,b =map(int,input().split())
print(a*(a-1)/2 + b*(b-1)/2)

Fixed code:
a,b =map(int,input().split())
print((a*(a-1))//2 + (b*(b-1))//2)
Buggy code:
n, m = map(int, input().split())
oo = n * (n-1) / 2
ee = m * (m-1) / 2

print(oo + ee)


Fixed code:
n, m = map(int, input().split())
oo = n * (n-1) / 2
ee = m * (m-1) / 2

print(int(oo + ee))
Buggy code:
def resolve():
    n, m = map(int,input().split())
    a = (n+m)*(n+m-1)/2
    b = n*m
    print(a-b)
resolve()

Fixed code:
def resolve():
    n, m = map(int,input().split())
    a = (n+m)*(n+m-1)/2
    b = n*m
    print(int(a-b))
    
    
resolve()
Buggy code:
n, m = map(int, input().split())

print(
  n * (n - 1) + m * (m - 1) // 2
)

Fixed code:
n,m = map(int,input().split())

print((n*(n-1))//2+(m*(m-1))//2)
Buggy code:
even, odd = map(int,input().split())
print((even*~-n // 2) + (odd*=~-odd // 2))

Fixed code:
even, odd = map(int,input().split())
print((even*~-even // 2) + (odd*~-odd // 2))
Buggy code:
N, M = map(int,input().split())

print(int(N(N-1)//2 + M(M-1)//2))


Fixed code:
N, M = map(int,input().split())
print((N * (N - 1) // 2) + (M * (M - 1) // 2))
Buggy code:
n,m = [int(x) for x in input().split()]
print(n * (n-1) / 2 + m * (m-1) / 2)

Fixed code:
n,m = [int(x) for x in input().split()]
print((n * (n-1) // 2) + (m * (m-1) // 2))
Buggy code:
from sys import stdin,setrecursionlimit
n,m = map(int,stdin.readline().rstrip().split())
print(n*(n-1)+m*(m-1))

Fixed code:
from sys import stdin,setrecursionlimit
n,m = map(int,stdin.readline().rstrip().split())
print(n*(n-1)//2+m*(m-1)//2)
Buggy code:
n, m = map(int, input().split())
print(n*(n-1)/2 +m*(m-1)/2 )

Fixed code:
n, m = map(int, input().split())

ans = n*(n-1)//2 + m*(m-1)//2

print(ans)
Buggy code:
n, m = map(lambda i: int(i), input().split())

if n == 1 and m ==1:
    print(0)

print(int(n*(n-1)/2 + m*(m-1)/2))

Fixed code:
n, m = map(lambda i: int(i), input().split())

if n == 1 and m ==1:
    print(0)
else:
    print(int(n*(n-1)/2 + m*(m-1)/2))
Buggy code:
N,M= map(int,input().split())

K=(N+M)*(N+M-1)/2-N*M
print(K)

Fixed code:
N, M = map(int, input().split())
print(N * (N - 1) // 2 + M * (M - 1) // 2)
Buggy code:
a, b = map(int, input().split())

ans = (a * (a - 1) / 2) + (b * (b - 1) / 2)
print(ans)


Fixed code:
a, b = map(int, input().split())

ans = round((a * (a - 1) / 2) + (b * (b - 1) / 2))
print(ans)
Buggy code:
data = input().split(" ")

N = int(data[0])
M = int(data[1])

ans = N*(N-1)/2
ans += M*(M-1)/2

print(ans)


Fixed code:
data = input().split(" ")
 
N = int(data[0])
M = int(data[1])
 
ans = N*(N-1)/2
ans += M*(M-1)/2
 
print(int(ans))
Buggy code:
N, M = map(int, input().split())

ans =  N * (N + 1) / 2 + M * (M + 1) / 2

print(int(ans))

Fixed code:
N, M = map(int, input().split())

ans =  N * (N - 1) / 2 + M * (M - 1) / 2

print(int(ans))
Buggy code:
a, b = map(int, input().split())

k = 0

if a%2 == 0:
  k = k + a*(a-1)/2
else:
  k = k
  
if b%2 == 0:
  k = k + b*(b-1)/2
else:
  k = k
  
print(k)


Fixed code:
a, b = map(int, input().split())
 
k = 0
 
if a != 1:
  k = k + a*(a-1)/2
else:
  k = k
  
if b != 1:
  k = k + b*(b-1)/2
else:
  k = k
  
print(int(k))
Buggy code:
a,b = map(int, input().split(" "))
n = a + b
print(n*(n-1)//2 - b * (b-1)//2)

Fixed code:
a,b = map(int, input().split(" "))
n = a + b
print(n*(n-1)//2 - b * a)
Buggy code:
N, M = (int(x) for x in input().split())
print(N*(N-1)/2+M*(M-1)/2)

Fixed code:
N, M = (int(x) for x in input().split())
print(N*(N-1)//2+M*(M-1)//2)
Buggy code:
e,o = map(int, input().split())
print(e * (e - 1) / 2 + o * (o - 1) / 2)

Fixed code:
e,o = map(int, input().split())
print(int(e * (e - 1) / 2 + o * (o - 1) / 2))
Buggy code:
N,M = map(int,input().split())

ans = N*M + M(M-1)//2
print(ans)

Fixed code:
N, M = map(int, input().split())
print(N * (N - 1) //2 + M * (M - 1) // 2)
Buggy code:
def c(i):
    return i*(i-1)/2

n,m=map(int,input().split())
print(c(n)+c(m))


Fixed code:
def c(i):
    return i*(i-1)//2

n,m=map(int,input().split())
print(c(n)+c(m))
Buggy code:
N, M = map(int, input().split())
method1 = N*(N-1)/2
method2 = M*(M-1)/2
method=method1+method2
print(str(method))


Fixed code:
N, M = map(int, input().split())
method1 = N*(N-1)/2
method2 = M*(M-1)/2
method=method1+method2
print(str(round(method)))
Buggy code:
m, n = map(int, input().split())
print(m * (m - 1)/2 + n * (n - 1)/2)

Fixed code:
n,m = map(int,input().split())

print(n*(n-1)//2 + m*(m-1)//2)
Buggy code:
N, M = map(int, input().split())
print((N*(N-1)/2)+(M*(M-1)/2))

Fixed code:
N,M=map(int,input().split())

print(int((N*(N-1)/2)+M*(M-1)/2))
Buggy code:
n, m = map(int, input().split())
if n == 1:
  if m == 1:
    print(0)
  else:
    print((m * (m-1) / 2))
elif m == 1:
  print((n * (n-1) / 2))
else:
  print((n * (n-1) / 2) + (m * (m-1) / 2))

Fixed code:
n, m = map(int,input().split())

if n==1 and m==1:
    print(0)
else:
    print(int(n*(n-1)/2 + m*(m-1)/2))
Buggy code:
N, M = map(int, input().split())

if N == int(0):
    print(M*(M-1)/2)
elif M == int(0):
    print(N*(N-1)/2)
else:
    print(N*(N-1)/2 + M*(M-1)/2)

Fixed code:
N, M = map(int, input().split())

if N == int(0):
    print(int(M*(M-1)/2))
elif M == int(0):
    print(int(N*(N-1)/2))
else:
    print(int(N*(N-1)/2 + M*(M-1)/2))
Buggy code:
n, m = map(int, input().split())
print((n * (n-1) / 2) + (m * (m-1) / 2))

Fixed code:
n,m = map(int, input().split())

ans = n*(n-1) + m*(m-1)
ans /= 2
print(int(ans))
Buggy code:
n, m = map(int, input().split())
a = n*(n-1)/2 + m*(m-1)/2
print(a)

Fixed code:
n, m = map(int, input().split())
a = n*(n-1)/2 + m*(m-1)/2
print(int(a))
Buggy code:
n,m = map(int, input().split())
print(n*(n-1)/2 + m*(m-1)/2)

Fixed code:
n, m = map(int, input().split())
ans = n * (n - 1) // 2 + m * (m - 1) // 2
print(ans)
Buggy code:
NM=input().split()
N=int(NM[0])
M=int(NM[1])
print(N*(N-1)/2+M*(M-1)/2)

Fixed code:
NM=input().split()
N=int(NM[0])
M=int(NM[1])
print(int((N*(N-1)+M*(M-1))/2))