qyliang/CodeNanoFix huggingface dataset:
Buggy code:
a, b, h = (int(input()) for u in range(3))
print((a + b) * h / 2)

Fixed code:
a, b, h = (int(input()) for u in range(3))
print((a + b) * h // 2)
Buggy code:
a = input()
b = input()
h = input()
print int(((a+b)/2)*h)

Fixed code:
a = int(input())
b = int(input())
h = int(input())

print(h*(a+b)//2)
Buggy code:
a = int(input())
b = int(input())
h = int(input())
print((a+b)*(h/2))

Fixed code:
a=int(input())
b=int(input())
h=int(input())
print(int((a+b)*h//2))
Buggy code:
def main():
    a = int(input())
    b = int(input())
    h = int(input())
    print((a+b)*h/2)

if __name__ == '__main__':
    main()

Fixed code:
def main():
    a = int(input())
    b = int(input())
    h = int(input())
    print((a+b)*h//2)


if __name__ == "__main__":
    main()
Buggy code:
a = int(input())
b = int(input())
h = int(input())

area = (a + b) * h /2

print(area)

Fixed code:
a = int(input())
b = int(input())
h = int(input())

area = (a + b)*h//2
print(area)
Buggy code:
input_ = [input() for i in range(3)]

a, b, h = input_

s = (int(a) + int(b)) * int(h) / 2

print(s)

Fixed code:
a,b,h = [int(input()) for i in range(3)]
print((a+b)*h//2)
Buggy code:
a = int(input())
b= int(input())
h = int(input())
print((a+b)*h/2)

Fixed code:
a = int(input())
b= int(input())
h = int(input())
print((a+b)*h//2)
Buggy code:
print((int(input())+int(input()))*int(input()//2)

Fixed code:
print((int(input())+int(input()))*int(input())//2)
Buggy code:
a, b, h, = [int(input()) for i in range(3)]
print((a+b)*h/2)

 

Fixed code:
a,b,h = (int(input()) for i in range(3))
print((a+b)*h//2)
Buggy code:
    a = input()
    b = input()
    h = input()
    print (a+b)*h/2

Fixed code:
a = int(input())
b = int(input())
h = int(input())
print((a + b) * h // 2)
Buggy code:
A = int(input())
B = int(input())
H = int(input())

print((A+B)*H/2)

Fixed code:
A = int(input())
B = int(input())
H = int(input())
answer = (H*(A+B)//2)

print(answer)
Buggy code:
a,b,h=map(int,open(0))

print((a+b)*h/2)

Fixed code:
a,b,h=map(int,open(0))
 
print((a+b)*h//2)
Buggy code:
a,b,h=[int(input())for _ in range(3)];print((a+b)*h/2)

Fixed code:
a,b,h=[int(input())for _ in range(3)];print((a+b)*h//2)
Buggy code:
a = int(input())
b = int(input())
h = int(input())
print((a + b)*h/2)

Fixed code:
a,b,h = int(input()),int(input()),int(input())
print((a+b)*h//2)
Buggy code:
a=int(input())
b=int(input())
h=int(input())

print((a+b)*h/2)

Fixed code:
a = int(input())
b = int(input())
h = int(input())

ans = (a+b) * h // 2
print(ans)
Buggy code:
a,b,h  = [int(input()) for  i in range(3)]
print((a+b)*h/2)


Fixed code:
a,b,h = [int(input()) for i in range(3)]
print((a + b) * h // 2)
Buggy code:
a = int(input())
b = int(input())
h = int(input())

S = (a+b) * h / 2

print(S)

Fixed code:
a = int(input())
b = int(input())
h = int(input())
print((a+b) * h //2)
Buggy code:
a= int(input())
b= int(input())
h= int(input())
print((a+b)*h/2)

Fixed code:
a = int(input())
b = int(input())
h = int(input())

print( (a+b) * h // 2)
Buggy code:
print(int((int(input()) + int(input)) * int(input()) / 2))

Fixed code:

print((int(input())+int(input()))*int(input())//2)
Buggy code:
a=int(input())
b=int(input())
h=int(input())

S=(a+b)*h/2

print(S)

Fixed code:
a=int(input())
b=int(input())
h=int(input())
print(h*(a+b)//2)
Buggy code:
a = list(int(input()) for _ in range(3))

print((a[0]+a[1])*a[2]/2)

Fixed code:
a = list(int(input()) for _ in range(3))
print((a[0]+a[1])*a[2]//2)
Buggy code:
a = int(input())
b = int(input())
h = int(input())
print(str((a + b)*h/2))


Fixed code:
a = int(input())
b = int(input())
h = int(input())
print(str((a + b)*h//2))
Buggy code:
a=int(input())
b=int(input())
h=int(input())
s=((a+b)*h)/2
print(s)

Fixed code:
a = int(input())
b = int(input())
h = int(input())
s = (a+b)*h//2
print(s)
Buggy code:
#!/usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
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 = float('INF')

#A
def A():
    a, b, h = IR(3)
    print((a+b)*h/2)
    return

#B
def B():
    return

#C
def C():
    return

#D
def D():
    return

#E
def E():
    return

#F
def F():
    return

#G
def G():
    return

#H
def H():
    return

#Solve
if __name__ == '__main__':
    A()


Fixed code:
#!/usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
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 = float('INF')

#A
def A():
    a, b, h = IR(3)
    print((a+b)*h//2)
    return

#B
def B():
    return

#C
def C():
    return

#D
def D():
    return

#E
def E():
    return

#F
def F():
    return

#G
def G():
    return

#H
def H():
    return

#Solve
if __name__ == '__main__':
    A()
Buggy code:
a = int(input())
b = int(input())
h = int(input())

print((a + b) * h / 2)


Fixed code:
a = int(input())
b = int(input())
h = int(input())

S = (a+b)*h // 2
print(S)
Buggy code:
a = int(input())
b = int(input())
h = int(input())

s = (a + b)*h/2
print(s)

Fixed code:
a = int(input())
b = int(input())
h = int(input())
 
print((a + b) * h // 2)
Buggy code:
a = int(input())
b = int(input())
h = int(input())

ans = (a+b)*h/2
print(ans)

Fixed code:
a = int(input())
b = int(input())
h = int(input())

ans = (a+b)*h//2
print(ans)
Buggy code:
a = int(input())
b = int(input())
h = int(input())

print(h * (a + b) / 2)

Fixed code:
a = int(input())
b = int(input())
h = int(input())


area = (a+b)*h//2
print(area)
Buggy code:
print(eval('(i*i)*i//2'.replace('i','int(input()')))

Fixed code:
print(eval('(i+i)*i//2'.replace('i','int(input())')))
Buggy code:
a = int(input())
b = int(input())
h = int(input())
print((a+b)*h/2)


Fixed code:
a = int(input())
b = int(input())
h = int(input())
 
area = (a + b)*h//2
print(area)
Buggy code:
#coding:utf-8

a = int(input())
b = int(input())
h = int(input())

print(((a+b)*h)/2)

Fixed code:
#coding:utf-8

a = int(input())
b = int(input())
h = int(input())

print(((a+b)*h)//2)
Buggy code:
a,b,h = [int(input()) for i in range(3)]
print((a+b)*h/2)

Fixed code:
a,b,c =[int(input())for i in range(3)]
print((a+b)*c//2)
Buggy code:
a = int(input())
b = int(input())
h = int(input())


print((a + b) * h / 2)


Fixed code:
a = int(input())
b = int(input())
h = int(input())


print((a + b) * h // 2)
Buggy code:
a,b,h= map(int,open(0).read().split())
print((a+b)*h/2)

Fixed code:
a,b,h= map(int,open(0).read().split())
print((a+b)*h//2)
Buggy code:
a=int(input())
b=int(input())
h=int(input())
print((a+b)/2*2)

Fixed code:
a = int(input())
b = int(input())
h = int(input())

print(int((a+b)*h//2))
Buggy code:
a,b,h=[int(input()) for i in range(3)]
print(a*b*h/2)
           

Fixed code:
a,b,h=[int(input()) for i in range(0,3)]
print((a+b)*h//2)
Buggy code:

def main():
    a = int(input())
    b = int(input())
    h = int(input())
    print((a + b) * h / 2)
    

if __name__ == "__main__":
    main()


Fixed code:

def main():
    a = int(input())
    b = int(input())
    h = int(input())
    print((a + b) * h // 2)


if __name__ == "__main__":
    main()
Buggy code:
a=int(input())
b=int(input())
h=int(input())
 
(a+b)*h/2

Fixed code:
a = int(input())
b = int(input())
h = int(input())
print( (a+b)*h//2 )
Buggy code:
a = int(input())
b = int(input())
h = int(input())

print((a+b) * h / 2)

Fixed code:
a = int(input())
b = int(input())
h = int(input())

ans = (a + b) * h // 2

print(ans)
Buggy code:
a, b, h = [int(input()) for _ in range(3)]
print((a+b)*h/2)


Fixed code:
a, b, h = [int(input()) for _ in range(3)]
print((a+b)*h//2)
Buggy code:
a=int(input())
b=int(input())
c=int(input())

print((a+b)*c/2)

Fixed code:
a=int(input())
b=int(input())
c=int(input())

print((a+b)*c//2)
Buggy code:
a = int(input())
b = int(input())
h = int(input())
ans = (a+b) * h / 2
print(ans)


Fixed code:
a=int(input())
b=int(input())
h=int(input())
print((a+b)*h//2)
Buggy code:
a = int(input())
b = int(input())
c = int(input())

print((a+b) * c/2)

Fixed code:
a=int(input())
b=int(input())
c=int(input())
area=(a+b)*c//2
print(area)
Buggy code:
# -*- coding: utf-8 -*-

a = int(input())
b = int(input())
h = int(input())

S = (a + b) * h / 2
print(S)


Fixed code:
# # -*- coding: utf-8 -*-
a = int(input())
b = int(input())
h = int(input())

print((a + b) * h // 2)
Buggy code:
a = int(input())
b = int(input())
h = int(input()) 
print((a+b)*h/2)

Fixed code:
a = int(input())
b = int(input())
h = int(input())
s = (a+b) * h // 2
print(s)
Buggy code:
a, b, h = (int(input()) for _ in range(3))
print((a+b)*h/2)

Fixed code:

a, b, h = [int(input()) for _ in range(3)]

print((a + b) * h // 2)
Buggy code:
a = int(input())
b = int(input())
h = int(input())

print(str((a+b)*h/2))

Fixed code:
a = int(input())
b = int(input())
h = int(input())

print((a + b) * h // 2)
Buggy code:
#!/use/bin/env python3

from collections import defaultdict

(a, b, h) = [int(input()) for _ in range(0, 3)]

print((a + b) * h /2)


Fixed code:
#!/use/bin/env python3

from collections import defaultdict

(a, b, h) = [int(input()) for _ in range(0, 3)]

print((a + b) * h // 2)
Buggy code:
a, b, h = int(input()), int(input()), int(input())
print((a + b) * h / 2)


Fixed code:
a, b, h = int(input()), int(input()), int(input())
print((a + b) * h // 2)
Buggy code:
a = int(input())
b = int(input())
h = int(input())

print((a+b)/2 * h)

Fixed code:
a=int(input())
b=int(input())
h=int(input())

ans = (a+b)*h//2
print(ans)
Buggy code:
import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict, deque

sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    a, b, h = ii(), ii(), ii()
    print(((a + b) * 2) / 2)


if __name__ == '__main__':
    main()


Fixed code:
import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict, deque

sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    a = ii()
    b = ii()
    h = ii()
    print(((a+b)*h)//2)


if __name__ == '__main__':
    main()
Buggy code:
a = int(input())
b = int(input())
h = int(input())

print((a + b) * h / 2))


Fixed code:
a = int(input())
b = int(input())
h = int(input())
r = (a+b)*h//2
print(r)
Buggy code:
[i for i in [a,b,h]=[int(input()) for i in range(3)]
print((a+b)*h/2)

Fixed code:
[a,b,h]=[int(input()) for i in range(3)]
print((a+b)*h//2)
Buggy code:
a = int(input())
b = int(input())
h = int(input())

print((a + b) * h / 2)



Fixed code:
a = int(input())
b = int(input())
h = int(input())
S = (a+b)*h
print(S//2)
Buggy code:
a = int(input())
b = int(input())
c = int(input())

print(((a + b) * c) / 2)

Fixed code:
a = int(input())
b = int(input())
c = int(input())
print((a+b)*c//2)
Buggy code:
a = int(input())
b = int(input())
h = int(input())
s = (a + b) * h /2
print(s)

Fixed code:
a = int(input())
b = int(input())
h = int(input())
s = (a+b) * h //2
print(s)
Buggy code:
a=int(input())
b=int(input())
h=int(input())

print(((a+b)*h)/2)



Fixed code:
a = int(input())
b = int(input())
h = int(input())

ans = (a + b) * h // 2

print(ans)
print()
Buggy code:
import sys
from itertools import permutations

def solve():
    input = sys.stdin.readline
    a = int(input())
    b = int(input())
    h = int(input())
    print((a + b) * h / 2)
    return 0

if __name__ == "__main__":
    solve()

Fixed code:
import sys
from itertools import permutations

def solve():
    input = sys.stdin.readline
    a = int(input())
    b = int(input())
    h = int(input())
    print((a + b) * h // 2)
    return 0

if __name__ == "__main__":
    solve()
Buggy code:
def calc_trapezoid_area(top_length, under_length, height):    
    return top_length + under_length * height / 2

if __name__=='__main__':
    top_length, under_length, height = map(int, [input() for i in range(3)])
    print(calc_trapezoid_area(top_length, under_length, height))

Fixed code:
def calc_trapezoid_area(top_length, under_length, height):    
    return (top_length + under_length) * height // 2

if __name__=='__main__':
    top_length, under_length, height = map(int, [input() for i in range(3)])
    print(calc_trapezoid_area(top_length, under_length, height))
Buggy code:
a, b, h = [int(input()) for _ in range(3)]
print((a + b) * 2 // h)

Fixed code:
a, b, h = [int(input()) for _ in range(3)]
area = (a + b) * h // 2
print(area)
Buggy code:
a = int(input())
b = int(input())
h = int(input())
print((a+b)*h/2)



Fixed code:
a = int(input())
b = int(input())
h = int(input())
s = (a + b) * h // 2
print(s)
Buggy code:
  a, b, h = [int(input()) for _ in range(3)]
  print((a+b)*h / 2)


Fixed code:
a, b, h= (int(input()) for _ in range(3))
print((a+b)*h // 2)
Buggy code:
  a, b, h = (int(input()) for i in range(3))
  print((a+b)*h / 2)

Fixed code:
a, b, h = (int(input()) for i in range(3))
print((a + b) * h // 2)
Buggy code:
a = int(input())
b = int(input())
h = int(input())

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

Fixed code:
a = int(input())
b = int(input())
h = int(input())
print((a+b)*h // 2)
Buggy code:
a = int(input())
b = int(input())
h = int(input())

print(((a + b) / 2 ) * h)

Fixed code:
a, b, h = int(input()), int(input()), int(input())
print((a+b)*h//2)
Buggy code:
# -*- coding: utf-8 -*-
a = int(input())
b = int(input())
h = int(input())
men = (a + b) * h /2
print(men)

Fixed code:
# -*- coding: utf-8 -*-
a = int(input())
b = int(input())
h = int(input())
men = (a + b) * h // 2
print(men)
Buggy code:
a,b,h=(int(input())for _ in[0]*3);print((a+b)*h/2)

Fixed code:
a,b,h=(int(input())for _ in[0]*3);print((a+b)*h//2)
Buggy code:
string_list = [input() for i in range(3)]

a = int(string_list[0])
b = int(string_list[1])
h = int(string_list[2])

answer = (a+b)*h/2

print(answer)


Fixed code:
string_list = [input() for i in range(3)]

a = int(string_list[0])
b = int(string_list[1])
h = int(string_list[2])

answer = (a+b)*h//2

print(answer)
Buggy code:
a=int(input())
b=int(input())
h=int(input())

print((a+b)*h/2)



Fixed code:

a = int(input())
b = int(input())
h = int(input())

print  (((a+b)*h) // 2 )
Buggy code:
a,b,c=[int(input()) for i in range(3)]

print((a+b)*c/2)

Fixed code:
a,b,h = [int(input()) for i in range(3)]
print(h*(a+b)//2)
Buggy code:
a = int(input)
b = int(input)
h = int(input)
print((a+b)*(h/2))

Fixed code:
a, b, h = int(input()), int(input()), int(input())
print((a + b) * h // 2)
Buggy code:
a=int(input());b=int(input());h=int(input())

print((a+b)/2*h)

Fixed code:
a = int(input())
b = int(input())
h = int(input())

print(((a+b) * h) // 2)
Buggy code:
a,b,c=map(int,open(0));print(a*b*c/2)

Fixed code:
a,b,c=map(int,open(0));print((a+b)*c//2)
Buggy code:
x = lambda:int(input())
print((x()*x())*x()//2)


Fixed code:
x = lambda:int(input())
print((x()+x())*x()//2)
Buggy code:
a = int(input())
b = int(input())
h = int(input())
print((a+b) * h / 2)


Fixed code:
a = int(input())
b = int(input())
h = int(input())
ans = (a+b) * h // 2
print(ans)
Buggy code:
a=input();b=input();h=input()

print((a+b)/2*h)

Fixed code:
a=int(input());b=int(input());h=int(input())

print((a+b)*h//2)
Buggy code:
a,b,h=[int(i) for i in range(3)]
print((a+b)*h//2)

Fixed code:
a, b, h = [int(input()) for i in range(3)]
print((a+b)*h//2)
Buggy code:
a = int(input())
b = int(input())
h = int(input())
print((a + b) * h / 2)



Fixed code:
a = int(input())
b = int(input())
h = int(input())

ans = (a+b)*h//2
print(ans)
Buggy code:
a=input()
b=input()
h=input()
print((a+b)*h/2)

Fixed code:
a=input()
b=input()
h=input()
a=int(a)
b=int(b)
h=int(h)
print((a+b)*h//2)
Buggy code:
a = int(input())
b = int(input())
h = int(input())

print((a+b)*h/2)


Fixed code:
a = int(input())
b = int(input())
h = int(input())

answer = (a + b) * h // 2

print(answer)
Buggy code:
import sys


def getN():
    return int(input())


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


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


def input():
    return sys.stdin.readline().rstrip()


#############
# Main Code #
#############
a = getN()
b = getN()
h = getN()
print((a + b) / 2 * h)


Fixed code:
import sys


def getN():
    return int(input())


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


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


def input():
    return sys.stdin.readline().rstrip()


#############
# Main Code #
#############
a = getN()
b = getN()
h = getN()
print(h * (a + b) // 2)
Buggy code:
a=int(input())
b=int(input())
c=int(input())
print(((a+b)*h)//2)
  

Fixed code:
a=int(input())
b=int(input())
c=int(input())
print(((a+b)*c)//2)
Buggy code:
a,b,h = (int(input()) for i in range(3))

print((a+b)*h/2)


Fixed code:
a,b,h = (int(input()) for i in range(3))
 
print((a+b)*h//2)
Buggy code:
up=int(input())
down=int(input())
h=int(input())
print((up+down)*h/2)

Fixed code:
up=int(input())
down=int(input())
h=int(input())
print((up+down)*h//2)
Buggy code:
a = int(input())
b = int(input())
c = int(input())

print((a+b)*h//2)

Fixed code:
a = int(input())
b = int(input())
c = int(input())

print((a + b) * c // 2)
Buggy code:
a = int(input())
b = int(input())
h = int(input())  

print((a+b)*h/2)

Fixed code:
a = int(input())
b= int(input())
h=int(input())

print((a+b)*h//2)
Buggy code:
# ABC045a
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

a = int(input())
b = int(input())
h = int(input())
print((a+b)*h/2)


Fixed code:
# ABC045a
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

a = int(input())
b = int(input())
h = int(input())
print((a+b)*h//2)
Buggy code:
import sys, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')



def solve():
    a,b,h = f()
    print((a+b)*h//2)

solve()


Fixed code:
import sys, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')



def solve():
    a = f()[0]
    b = f()[0]
    h = f()[0]
    print((a+b)*h//2)

solve()
Buggy code:
a = int(input())
b = int(input())
h = int(input())
result = (a + b) * h / 2
print(result)


Fixed code:
a=int(input())
b=int(input())
h=int(input())

print(h*(a+b)//2)
Buggy code:
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
inf = 10**17
mod = 10**9 + 7


a,b,h=MI()
ans=(a+b)*h//2
print(ans)

Fixed code:
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
inf = 10**17
mod = 10**9 + 7


a=I()
b=I()
h=I()
ans=(a+b)*h//2
print(ans)
Buggy code:
a,b,c=[int(input()) for i range(3)]
print(((a+b)*c)/2)

Fixed code:
a,b,c=[int(input()) for i in range(3)]
print(((a+b)*c)//2)
Buggy code:
a=int(input())
b=int(input())
h=int(inupt())
print((a+b)*h/2)

Fixed code:
a = int(input())
b = int(input())
h = int(input())
print(h*(a+b)//2)
Buggy code:
a=int(input()
b=int(input()
h=int(input()
print((a+b)*h//2)

Fixed code:
a = int(input())
b = int(input())
h = int(input())

result = (a + b ) * h // 2
print(result)
Buggy code:
a.b.h= [int(input()) for i in range(3)]
print(int((a+b)*h/2))

Fixed code:
a, b, h = [int(input()) for i in range (3)]

print((a+b)*h//2)
Buggy code:
a = int(input())
b = int(input())
h = int(input())

print(int((a+b)*h //2)

Fixed code:
a = int(input())
b = int(input())
h = int(input())
 
print(int((a+b)*h//2))
Buggy code:
a,b,h=[int(input()) for i in range(3)]

print((a+b)*h/2)

Fixed code:
a,b,h=[int(input()) for i in range(3)]

print((a+b)*h//2)
Buggy code:
a = int(input())
b = int(input())
h = int(input())
ans = (a+b)*h/2
print()ans

Fixed code:
a = int(input())
b = int(input())
h = int(input())

ans = (a + b) * h // 2
print(ans)
Buggy code:
a = int(input())
b = int(input())
c = int(input())
print(((a + b) * h) // 2)

Fixed code:
a = int(input())
b = int(input())
c = int(input())
print(((a + b) * c) // 2)
Buggy code:
a,b,h=[int(input()) for i in range(3)]
print((a+b)*h/2)

Fixed code:
a, b, h = [int(input()) for _ in range(3)]
print((a+b)*h//2)
Buggy code:
A = int(input())
B = int(input())
H = int(input())

print((A + B)*H/2)

Fixed code:
A = int(input())
B = int(input())
H = int(input())

print(int((A + B)*H//2))
Buggy code:
a=int(input())
b=int(input())
h=int(input())
c=a+b
print(h*c/2)

Fixed code:
a = int(input())

b= int(input())


c= int(input())
print((a+b)*c//2)