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

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())
n=N*(N-1)
m=M*(M-1)
print((n+m)/2)

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

Fixed code:
N,M = map(int,input().split())
ans1 = N*(N-1)//2
ans2 = M*(M-1)//2
A = ans1+ans2
print(A)
Buggy code:
n , m= list(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 = n * (n - 1) // 2 + m * (m - 1) // 2
print(ans)
Buggy code:
N,M=list(map(int,input().split()))
print(N*(N-1)/2+M*(M-1)/2)

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

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

print(ans)


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

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

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

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

Fixed code:
n, m = map(int, input().split())
a=(n*(n-1))/2+(m*(m-1))/2
a=int(a)
print(a)
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 = int(n*(n-1)/2) + int(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(a+b)
Buggy code:
N,M = input().split()

N = int(N)
M = int(M)

even = 0
odd = 0
final = 0

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

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

N = int(N)
M = int(M)

even = 0
odd = 0
final = int

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

Fixed code:
N,M = map(int,input().split())
sum = 0
sum+=N*(N-1)/2
sum+=M*(M-1)/2
print(int(sum))
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(M*(M-1)//2+N*(N-1)//2)
Buggy code:
n,m=map(input().split())

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

print(str(a))
  

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

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

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


print ((m*(m-1) + n*(n-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:
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)/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,w=map(int,input().split())
print(n*(n-1)/2+w*(w-1)/2)

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

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

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

if M == 0:
    print(int((N * (N - 1)) / 2))
elif N == 0:
    print(int((M * (M - 1)) / 2))
    
else:
    print(int(((M * (M - 1)) + (N * (N - 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())
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:
str1 =str(input())
s1 = str1.split(' ')
m = int(s1[0])
n = int(s1[1])
x = (m*(m+1))//2
y = (n*(n+1))//2
print(x+y)

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

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

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())

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)

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

print(x)

Fixed code:
N, M = map(int, input().split())
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 = map(int, input().split())
print(int((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:
a,b = map(int,input().split())
if (a >= 1) and (b >= 1):
    print(str(a*(a-1)/2 + b*(b-1)/2))
elif (a == 0) and (b == 0):
    print(str("0")
elif (a == 0):
    print(str(b*(b-1)/2))
else:
    print(str(a*(a-1)/2))


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


Fixed code:
n, m = map(int, input().split())
print((m*(m-1))//2+(n*(n-1))//2)
Buggy code:
n,m = 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:
#!/usr/bin/ python3.8
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
 
N, M = map(int, readlines().split())
x = M * (M - 1) // 2
x += N * (N - 1) // 2
print(x)

Fixed code:
#!/usr/bin/ python3.8
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
 
N, M = map(int, readline().split())
x = M * (M - 1) // 2
x += N * (N - 1) // 2
print(x)
Buggy code:
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

Fixed code:
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
 
N, M = list(map(int,input().split()))
print(int(N * (N-1) /2 + M * (M-1) / 2))
Buggy code:
n,m = input().split()
n = int(n)
m = int(m)
k = (n*(n-1) + m*(m-1))/2
print(k)

Fixed code:
n,m = input().split()
n = int(n)
m = int(m)
k = (n*(n-1) + m*(m-1))//2
print(k)
Buggy code:
n,m= map(int, input().split())
 
print(((n*(n-1))+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(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])


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

print(K)

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


K = N*(N-1)/2 + M*(M-1)/2
K = int(K)
print(K)
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())
C1 = N*(N-1)/2
C2 = M*(M-1)/2

print(C1 + C2)


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

print(C1 + C2)
Buggy code:
N,M = map(int,input().split())
if (N == 0 or N == 1) and (M == 0 or M == 1):
    print(0)
if (N == 0 or N == 1) and M != 0 and M != 1:
    print(M*(M-1)//2)
if N != 0 and N != 1 and (M == 0 or 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 == 0 or N == 1) and (M == 0 or M == 1):
    print(0)
elif (N == 0 or N == 1) and M != 0 and M != 1:
    print(M*(M-1)//2)
elif N != 0 and N != 1 and (M == 0 or M == 1):
    print(N*(N-1)//2)
else:
    print(N*(N-1)//2 + M*(M-1)//2)
Buggy code:
n, m = map(int,input(). split())
answer = (n+m)*(n+m-1)/2 - n*m
print(answer)

Fixed code:
n, m = map(int,input(). split())
answer = (n+m)*(n+m-1)//2-n*m
print(answer)
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())
sums = a * (a - 1) // 2 + b * (b - 1) // 2
print(sums)
Buggy code:
n,m=map(int,input().split())
print(n*(n-1)/2 + m*(m-1)/2)

Fixed code:
m,n =map(int,input().split())
print(int((n*n-n+m*m-m)/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(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())
ans = N*(N-1)//2 + 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 = list(map(int,input().split()))
print(int(N*(N-1)/2 + M*(M-1)/2))
Buggy code:
def main():
    import sys
    input = sys.stdin.buffer.readline
    n, m = map(int, input().split())
    print(int(n*(n-1)/2 + m(m-1)/2))


if __name__ == '__main__':
    main()

Fixed code:
def main():
    import sys
    input = sys.stdin.buffer.readline
    n, m = map(int, input().split())
    print(int(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:
m, n=map(int,input().split())
print((m-1)*m/2+(n-1)*n/2)

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

def choose2(x):
    return x * (n - 1) // 2

n, m = map(int, sys.stdin.readline().split())

def main():
    res = choose2(n) + choose2(m)
    print(res)

if __name__ ==  '__main__':
    main()

Fixed code:
import sys

n, m = map(int, sys.stdin.readline().split())

def main():
    res = n * (n - 1) // 2 + m * (m - 1) // 2
    return res

if __name__ == "__main__":
    ans = main()
    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())
nAns= (((n+1)*n)/2)-n
mAns= (((m+1)*m)/2)-m
print(int(nAns+mAns))
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 = list(map(int, input().split()))
print(int(a[0]*(a[0]-1)+a[1]*(a[1]-1)))

Fixed code:
a = list(map(int, input().split()))
print(int((a[0]*(a[0]-1)+a[1]*(a[1]-1))/2))
Buggy code:
from sys import stdin
N, M = map(int, input().split()) 

total = ((N+M)*(N+M-1))/2
odd = N*M

print(total - odd)




Fixed code:
from sys import stdin
N, M = map(int, input().split()) 

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

guusuu = (N * N-1) // 2
kisuu = (M * M-1) // 2

print(guusuu + kisuu)

Fixed code:
i = list(map(int, input().split()))
N = i[0]
M = i[1]

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

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

print((n * (n - 1) // 2) + (m * (m - 1) // 2))
Buggy code:
n, m = 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 = (int(x) for x in input().split())
sum = (n * (n - 1) / 2) + (m * (m - 1) / 2)
print(sum)

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

Fixed code:
n, m = (int(i) for i in 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())

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

if N==0 :
    print(M*(M-1)/2)
elif M==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==0 :
    print(M*(M-1)//2)
elif M==0 :
    print(N*(N-1)//2)
else :
    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)) + M * (M - 1))//2

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

n = N-1
m = M-1

Even = N*n
Odd = M*m

print((Even+Odd)/2)

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

M2=(M*(M-1))/2 #MC2
N2=(N*(N-1))/2
A=M2+N2
A

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

M2=(M*(M-1))/2 #MC2
N2=(N*(N-1))/2
A=M2+N2
A=int(A)
print(A)
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:
num = input("")
num = num.split(" ")
N = int(num[0])
M = int(num[1])
a = N*(N-1) if N*(N-1) >= 0 else 0
b = M*(M-1) if M*(M-1) >= 0 else 0
print(a + b)

Fixed code:
num = input("")
num = num.split(" ")
N = int(num[0])
M = int(num[1])
a = int(N*(N-1)/2) if N*(N-1) >= 0 else 0
b = int(M*(M-1)/2) if M*(M-1) >= 0 else 0
print(a + b)
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())

ans = (N)*(N-1)/2+M*(M-1)/2
print(int(ans))
Buggy code:
x = input().split
n = int(x[0])
m = int(x[1])
if n == 0:
  print(m * (m -1) /2)
elif m == 0:
  print(n * (n - 1) / 2)
else:
  k = m * (m -1) /2 + n * (n - 1) / 2
  print(k)

Fixed code:
x = input().split()
n = int(x[0])
m = int(x[1])
if n == 0:
  print(int(m * (m -1) /2))
elif m == 0:
  print(int(n * (n - 1) / 2))
else:
  k = m * (m -1) /2 + n * (n - 1) / 2
  print(int(k))
Buggy code:
import math
H, W = map(int, input().split())

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

Fixed code:
import math
H, W = map(int, input().split())

a = (H * (H-1))/2
b = (W * (W-1))/2

print(int(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:
a,b=map(int,input().split()):
c=0
d=d*(d-1)//2
e=e*(e-1)//2
while d>0:
  d=d-1
  c=c+1
while e>0:
  e=e-1
  c=c+1
print(c)  
  
 

Fixed code:
a,b=map(int,input().split())
c=0
d=a*(a-1)//2
e=b*(b-1)//2
while d>0:
  d=d-1
  c=c+1
while e>0:
  e=e-1
  c=c+1
print(c)
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=(int(x) for x in input().split());
print(n);
print(m);

even = n * (n-1) / 2 ;
odd = m * (m-1) /2 


Fixed code:
m,n=(int(x) for x in input().split());
even = m*(m-1)/2;
odd = n*(n-1)/2;

result = int(even + odd);
print(result);
Buggy code:
data = input().split()

a = int(data[0])
b = int(data[1])

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


Fixed code:
data = input().split()
 
a = int(data[0])
b = int(data[1])
ans = (a*(a-1)+b*(b-1))/2
print(int(ans))
Buggy code:
n,m=map(int,input().split())
  count=n*(n-1)//2
  countt=m*(m-1)//2
print(count+countt)


Fixed code:
n,m=map(int,input().split())
count=n*(n-1)//2
countt=m*(m-1)//2
print(count+countt)
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:
m, n = map(int,input().split())
print( m*(m-1)/2 + n*(n-1)/2 )


Fixed code:
m, n = map(int,input().split())
ans = int( m*(m-1)/2 + n*(n-1)/2 )
print(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())
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:
val = input().split(' ')
n = int(val[0])
m = int(val[1])

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

print(result)


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

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

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

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

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


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

Fixed code:
n,m=map(int,input().split())
print(((n-1)*n)//2+((m-1)*m)//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(round((n*(n-1) + m*(m-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(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())
l = n*(n-1)//2 + m*(m-1)//2
print(l)
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:
tmp = input().split(" ")
N = int(tmp[0])
M = int(tmp[1])

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

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

print(int(ans))
Buggy code:
s,t=(int(x) for x in input().split())
print(s*(s-1) /2 + t*(t-1)/2)

Fixed code:
s,t=(int(x) for x in input().split())
print(int(s*(s-1) /2 + t*(t-1)/2))
Buggy code:
n,m=map(int,input().split())
if n==0: 
    print(n*(n-1)/2)
elif m==0:
    print(m*(m-1)/2)
else:
    print(n*(n-1)+m*(m-1))

Fixed code:
n,m=map(int,input().split())
if n==0: 
    print(int(m*(m-1)/2))
elif m==0:
    print(int(n*(n-1)/2))
else:
    print(int(n*(n-1)/2+m*(m-1)/2))
Buggy code:
n, m = (int(i) for i in input().split());
res = (n * (n - 1) + m * (m - 1)) / 2;
print(res);

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

N1=(N*(N-1))/2
M1=(M*(M-1))/2

if N==0:
    print(M1)
elif M==0:
    print(N1)
else:
    print(M1+N1)

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

N1=(N*(N-1))/2
M1=(M*(M-1))/2

if N==0:
    print(int(M1))
elif M==0:
    print(int(N1))
else:
    print(int(M1+N1))
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) + M*(M-1)) // 2)
Buggy code:
N,M=map(int,input().split())
print((M(M-1)+N(N-1))/2)

Fixed code:
N,M=map(int,input().split())
print((N+M)*(N+M-1)//2-M*N)
Buggy code:
n,m = 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())
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)+int(odd))
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  = [int(i) for i in input().split()]
x = 0
x = a*(a-1)/2+b*(b-1)/2
print(x)



Fixed code:
a, b  = [int(i) for i in input().split()]
x = 0
x = a*(a-1)//2+b*(b-1)//2
print(x)
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:
ST = input().split()
N = ST[0]
M = ST[1]
print((N*(N-1)+(M*(M-1)))/2)

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

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

print( ans )

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

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

x=1
for n in range(1,N+1):
  x*=n
x/=2

y=1
for m in range(1,M+1):
  y*=m
y/=2

ans=int(x+y)
print(ans)

Fixed code:
A=input()
L=A.split()

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

x=1
for n in range(N-1,N+1):
  x*=n
x /= 2
  
y=1
for m in range(M-1,M+1):
  y*=m
y /= 2

print(int(x+y))
Buggy code:
a = [int(i) for i in input().split()]

x= a[0] * (a[0]-1) * (1/2)

x+= a[1] * (a[1]-1) * (1/2)

print(x)

Fixed code:
a = [int(i) for i in input().split()]

x= a[0] * (a[0]-1) * (1/2)

x+= a[1] * (a[1]-1) * (1/2)

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

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


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

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

print(int(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(int(M*(M-1)/2 + N*(N-1)/2))
Buggy code:
i = list(map(int, input().split()))
n = i[0]
m = i[1]

ans_n = 0
ans_m = 0

if n != 0 :
  ans_n = n*(n-1)/2
else:
  ans_n = 0
if m != 0 :
  ans_m = m*(m-1)/2
  
print(ans_n + ans_m)

Fixed code:
i = list(map(int, input().split()))
n = i[0]
m = i[1]

ans_n = 0
ans_m = 0
if(n == 0):
    ans_n = 0
else:
    ans_n = n*(n-1)//2
if(m == 0):
    ans_m = 0
else:
    ans_m = m*(m-1)//2

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

Fixed code:
N, M = map(int, input().split())
x = N + M
print(x * (x - 1) // 2 - N * M)
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*1 + M*(M-1)/2*1))
Buggy code:
n, m = map(int, input().split())
def col(x):
    if x == 0:
        return(0)
    else:
        return((x * (x - 1)) / 2)
print(col(n) + col(m))


Fixed code:
n, m = map(int, input().split())
def col(x):
    if x == 0:
        return(0)
    else:
        return((x * (x - 1)) // 2)
print(col(n) + col(m))
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)+M*(M-1))//2
print(ans)
Buggy code:
n, m = map(int,input().split())
x = (n*(n-1)) / 2
y = (m*(m-1)) / 2
print(x+y)



Fixed code:
n, m = map(int, input().split())
x = (n*(n-1)) // 2
y = (m*(m-1)) // 2
print(x+y)
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(a+b)
Buggy code:
# solution

n,m = map(int,input().split())
print("solution is")
print(n*(n-1)//2 + m*(m-1)//2)

Fixed code:
# solution

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)+M*(M-1))/2)

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

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