qyliang/CodeNanoFix huggingface dataset:
Buggy code:
A,P=map(int,input().split(" "))

B=A*3
Ans=B//2

print(Ans)

Fixed code:
A,P=map(int,input().split(" "))

B=A*3+P
Ans=B//2

print(Ans)
Buggy code:
a = int(input().split()[0])
p = int(input().split()[1])

s = a * 3 + p
print(s // 2)

Fixed code:
a = input().split()
an = int(a[0])
p = int(a[1])

s = an * 3 + p
print(s // 2)
Buggy code:
a, p = (int(v) for f in input().split(' '))
print((a*3 + p)//2)

Fixed code:
a, p = (int(v) for v in input().split(' '))
print((a*3 + p)//2)
Buggy code:
A,P=[int(x) for x in input().split()]

print(int((A*3)+P)/2)

Fixed code:
A, P = [int(i) for i in input().split()]
print( (A*3+P) // 2)
Buggy code:
a,p=map(int,input().split())↲
print(int((a*3+p)/2))


Fixed code:
a,p=map(int,input().split())
p+=3*a
print(p//2)
Buggy code:
A, P = map(int, input().split())
print((A*3+P)//P)


Fixed code:
A, P = map(int, input().split())
print((A * 3 + P)//2)
Buggy code:
a, p = map(int, input().split())
 (a*3+p)//2
 

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


Fixed code:
a,p=map(int,input().split())
c=a*3
b=(c+p)//2
print(b)
Buggy code:
import math

a, p = map(int, input().split())
p = p + math.floor(a / 3)
print(math.floor(p / 2))

Fixed code:
import math

a, p = map(int, input().split())
p = p + math.floor(a * 3)
print(math.floor(p / 2))
Buggy code:
n = int(input().split())

num1 =  ( n[0] * 3 + n[1] ) // 2

print(num1)

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

num1 =  ( int(n[0]) * 3 + int(n[1])) // 2

print(num1)
Buggy code:
if __name__ == '__main__':
  A, P = map(int, input().split())
  pieces = 3 * A + P
  apple_pi = pieces // 2
  
  print(pieces)

Fixed code:
if __name__ == '__main__':
  A, P = map(int, input().split())
  pieces = 3 * A + P
  apple_pi = pieces // 2
  
  print(apple_pi)
Buggy code:
A, P = int( x ) for x in input().split()
print( ( A * 3 + P ) // 2 )

Fixed code:
A,P=(int(x) for x in input().split())
A_p=3*A
print((P+A_p)//2)
Buggy code:
a, p = map(int, input().split())
print((a * 3 + p) / 2)


Fixed code:
a, p = map(int, input().split())
print( ( (a*3) + p) // 2)
Buggy code:

si = lambda: input()
ni = lambda: int(input())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))
a,p=nm()
print((3*a//2))


Fixed code:

si = lambda: input()
ni = lambda: int(input())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))
a,p=nm()
print(((3*a+p)//2))
Buggy code:
import math
A,P=map(int, input().split())
print(math.floor((3*a+P)/2))

Fixed code:
import math
A, P = map(int, input().split())
print(int(math.floor((A * 3 + P) / 2)))
Buggy code:
a,p=map(int,input().split())
ans=(3*a)//2
print(ans)

Fixed code:
a,p = map(int, input().split())
ans = (3*a+p)//2
print(ans)
Buggy code:
a,p = map(int,input().split())

print(3*a//2)

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

print((p+3*a)//2)
Buggy code:
a,p=map(int, input().split())
def crush(A):
    return A * 3

def create_apple_pie(piece):
    return piece // 2

create_apple_pie(crush(a) + p)

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

def crush(A):
    return A * 3

def create_apple_pie(piece):
    return piece // 2

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

Fixed code:
a,p = map(int,input().split())
print((a*3+p)//2)
Buggy code:
A, P = [int(_) for _ in input().split()]
print((3 * A + P)//3)

Fixed code:
A, P = [int(_) for _ in input().split()]
print((3 * A + P)//2)
Buggy code:
a,p=map(int,input().split())
print((3*a)//2)

Fixed code:
a, p = map(int, input().split())
print((a * 3 + p)//2)
Buggy code:
a, p = map(int, input().split())
print(int((a*2+p)//2))

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

print((3*a+p)//2)
Buggy code:
from collections import defaultdict, deque
import sys


def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]


a, p = LI()
sums = 3 * a + p
print(sums // 3)


Fixed code:
from collections import defaultdict, deque
import sys


def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]


a, p = LI()
sums = 3 * a + p
print(sums // 2)
Buggy code:
a , b = input().split()
print((a*3+b)//2)

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

Fixed code:
a,b=map(int,input().split())
print(((a*3)+b)//2)
Buggy code:
A,P = map(int,input().split())
print((A**3+P)//2)

Fixed code:
A,P=map(int, input().split())
P+=A*3
print(P//2)
Buggy code:
a,p = map(int, input().split())
print(((3*a+p)-(3*a+p)%2)/2)


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

Fixed code:
a, p = map(int, input().split())
to = 3 * a + p
print(to // 2)
Buggy code:
A,P = map(int,input(),split())
print((A*3+P)//2)

Fixed code:
A,P = map(int,input().split())
print((A * 3+ P) // 2)
Buggy code:
a,p=map(int,input().split())
print((3*a+p)//2))

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

Fixed code:
A, P = map(int, input().split())
if (3*A + P) % 2== 0:
    print(int((3*A + P) /2))
else:
    print(int((3*A + P-1)/2))
Buggy code:
def main():
    A ,P = map(int,input().split())
    print((A*3+P)//2) 

Fixed code:
def main():
    A ,P = map(int,input().split())
    print((A*3+P)//2) 

main()
Buggy code:
a,p = map(int,input().split())
print(a*3 + p // 2)

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

p = p + a * 3

print(p // 2)
Buggy code:
A, P = map(int, input().split())

piece = A * 3
pie = piece // 2
print(pie)


Fixed code:
A, P = map(int, input().split())

piece = A * 3
pie = (piece+P) // 2
print(pie)
Buggy code:
A, P = map(int, input().split())

Ringonokakera = (P+(A*3))

print(Ringonokakera//3)


Fixed code:
A, P = map(int, input().split())

Ringonokakera = (P+(A*3))

print(Ringonokakera//2)
Buggy code:
a,p = map(int, input().split())
sum = a*3+p
pi = sum/2
print(pi)


Fixed code:
a,p = map(int, input().split())
sum = a*3+p
pi = sum//2
print(pi)
Buggy code:
a,p = map(int,input().split())
print((a*3+p)/2)

Fixed code:
a,p=map(int,input().split())
a=a*3
print((a+p)//2)
Buggy code:
A, P = map(int, input().split())
print((A*3+P)/2)

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

print((A*3 + P)//2)
Buggy code:
A, P = map(int, input().split())

print((A*3+p)/2)

Fixed code:
A, P = map(int, input().split())

print( (A*3+P)//2 )
Buggy code:
num = input().split()

sum_apple = int(num[0])*3 + int(num[1])

print(sum_apple//3)

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

sum_apple = int(num[0]) * 3 + int(num[1])

print(sum_apple//2)
Buggy code:
a,p=map(int,input().split())
print((a+p//3)//2)

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

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


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

p = 3*a + p

pi = p // 2

print(pi)
Buggy code:
first=input()
(A, P)=first.split()
A=int(A)
P=int(P)
x=3*A
y=(x+P)/2
print(y)

Fixed code:
first=input()
(A, P)=first.split()
A=int(A)
P=int(P)
x=3*A
y=(x+P)//2
print(y)
Buggy code:
a,p=map(int,input().split())
print((a*3+p)//2

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

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

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

print((3*a + p)//2)
Buggy code:
A,P=map(int,input().split())
print(3*A+P//2)

Fixed code:
A,P = map(int, input().split())

print(((A*3)+P)//2)
Buggy code:
a, p = map(int, input().split())
pie = (a*3+p / 2)
print(int(pie))

Fixed code:

a,p=map(int,input().split())

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

sum = a*3 + b

p = sum/2

print(p)

Fixed code:
a,p=map(int,input().split())
sum=3*a+p
print(sum//2)
Buggy code:
a, p = map(int, input().split())
print(a*3+p//2)

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

r = a*3 + p
print(r//2)
Buggy code:
A,P = map(int,input().split())
B = A*3
AP  = B+P
Pie =  AP/2
print(Pie)


Fixed code:
A,P = map(int,input().split())
B = A*3
AP  = B+P
Pie =  AP//2
print(Pie)
Buggy code:
a, p = [int(x) for x in input().split()]
print((a // 3 + p) // 2)

Fixed code:
a, p = [int(x) for x in input().split()]
print((a * 3 + p) // 2)
Buggy code:
import numpy as np
A, P = map(int, input().split())
print((A/3+P)/2)

Fixed code:
import numpy as np
A, P = map(int, input().split())
print((A*3+P)//2)
Buggy code:
A, P = (int(i) for i in input().split()) 

print((2*A + P)//2)

Fixed code:
A, P = (int(i) for i in input().split()) 

print((3*A + P)//2)
Buggy code:
a, p = map(int, input().split())
print(int((a*3 + p)/2)

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

aaa = a*3+p

print(aaa//2)
Buggy code:
a,p=map(int,input().split())
print((a*3+2)//2)

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

p += a*3
print(p//2)
Buggy code:
A,P = map(int, input().split())

result =( A * 3 + P ) / 2

print(result)

Fixed code:
A,P = map(int, input().split())

result =( A * 3 + P ) // 2

print(result)
Buggy code:
A,P=map(int, input().split())
if (3*A+P)/2==0: print((3*A+P)/2)
else: print(int((3*A+P-1)/2))

Fixed code:
A,P=map(int, input().split())
if (3*A+P)%2==0: print(int((3*A+P)/2))
else: print(int((3*A+P-1)/2))
Buggy code:
A, P = map(int, input().split())
print((A*3 + p)//2)

Fixed code:
A,P=map(int,input().split())
print((P+3*A)//2)
Buggy code:
x,y = map(int,input().split())
a = (3*x+2)//2
print(a)

Fixed code:
x,y = map(int,input().split())
a = (3*x+y)//2
print(a)
Buggy code:
A,P = map(int,input().split())
print((A*3+P)/2)

Fixed code:
A, P = map(int, input().split(" "))
print((3*A +  P)//2)
Buggy code:
a,p = map(int,input().split())

print(((a*3)+2) // 2)

Fixed code:
a, p = list(map(int, input().split()))
print((3*a+p)//2)
Buggy code:
a, p = map(int, input().split())
print((3 * a + 2) // 2)

Fixed code:
a, p = map(int, input().split())
print((a  * 3 + p) // 2)
Buggy code:
A, P = map(int, input().split())
print((3*A+P)/2)

Fixed code:
A,P= map(int,input().split())

print((3*A+P)//2)
Buggy code:
a,p=map(int,input().split())
print((3 * a + p) / 2)


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

a_p = a*3

print((a_p + p) // 2)
Buggy code:
A, P = map(int,input().split())

print(((3 * A + P)-((3 * A + P) % 2)) / 2)

Fixed code:
A, P = map(int,input().split())

print(int(((3 * A + P)-((3 * A + P) % 2)) / 2))
Buggy code:
a,p=input().split()

print(int((a*3+p)/2))

Fixed code:
a,p = map(int,input().split())
print((a * 3 + p) // 2)
Buggy code:
A, P = [int(i) for i in input().split()]

print((3 * A + P//2))

Fixed code:
A, P = [int(i) for i in input().split()]

print((3 * A + P)//2)
Buggy code:
a,p=map(int,input().split())
ans=(a*3+b)//2
print(ans)


Fixed code:
a,p=map(int,input().split())
ans=(a*3+p)//2
print(ans)
Buggy code:
import sys
A, P = map(int, input().split())
ans = (A + 3*P) // 2

print(ans)

Fixed code:
import sys
A, P = map(int, input().split())
ans = (3*A + P) // 2
 
print(ans)
Buggy code:
print(eval(input().replace(' ','*3-')+'//2'))

Fixed code:
print(eval('('+input().replace(' ','*3+')+')//2'))
Buggy code:
A, P = map(int, input.split(" "))
print((3 * A + P) // 2)


Fixed code:
A, P = map(int, input().split(" "))
print((3 * A + P) // 2)
Buggy code:
a, p = map(int, input().split())
print(a * 3 + p // 2)


Fixed code:
a, p = map(int, input().split())
print((a * 3 + p) // 2)
Buggy code:
import math

a, p = map(int, input().sprit())

apple = 3 * a + p

ans = (math.floor(apple / 2))

print(ans)

Fixed code:
import math

a, p = map(int, input().split())

apple = 3 * a + p

ans = (math.floor(apple / 2))

print(ans)
Buggy code:
A,P = map(int, input().split())
print(int(A*3+P)/2)

Fixed code:
A, P = map(int, input().split())

kakera = 3 * A + P

print(kakera // 2)
Buggy code:
a,p=map(int,input().split())
print(a*3/2+p/2)

Fixed code:
a,p = map(int,input().split())
kakera = p + a * 3
print(kakera // 2)
Buggy code:
A, P =map(int,input().split())

print(int((A*3+p)/2))

Fixed code:
A, P = map(int,input().split())
print(((A*3)+P)//2)
Buggy code:
a, p = map(int, input().split())
p += a * 3
print(int(p/3))

Fixed code:
a, p = map(int, input().split())
p += 3*a
print(p//2)
Buggy code:
a,b=map(int,input().split())
c=(3*a+b)/2
import math
math.floor(c)

Fixed code:
a,b=map(int,input().split())
c=(3*a+b)/2
import math
print(math.floor(c))
Buggy code:
a,p=map(int,input().split())
print(int((a*3+2)/2))


Fixed code:
a, p = map(int, input().split())
print((3 * a + p)//2)
Buggy code:
    A,P = map(int,input().split())
    ans = 0
     
    A = int(A)
    P = int(P)
     
    P = (A*3) + P
    ans = P // 2
     
    print(ans)
     

Fixed code:
A,P = map(int,input().split())
ans = 0

A = int(A)
P = int(P)

P = (A*3) + P
ans = P // 2

print(ans)
Buggy code:
number = input().split(" ")
A = int(number[0])
P = int(number[1])
apple = (A * 3) + P
print(math.floor(apple / 2))

Fixed code:
import math

number = input().split(" ")
A = int(number[0])
P = int(number[1])
apple = (A * 3) + P
print(math.floor(apple / 2))
Buggy code:
A,P=map(int,input().split())
print(((A*3)//2 + b//2) + (((A**3)%2 + b%2)//2))

Fixed code:
A,P=map(int,input().split())
print(((A*3)//2 + P//2) + (((A*3)%2 + P%2)//2))
Buggy code:
a,p = map(int,input().split())
z = a*3+p
if z % 2 = 0:
  print(z/2)
else:
  print((z-1)/2)

Fixed code:
a,p = map(int,input().split())
z = a*3+p
if z % 2 == 0:
  print(int(z/2))
else:
  print(int((z-1)/2))
Buggy code:
n = list(map(int, input().split()))
print((n[0]*3+n[1])/2)

Fixed code:
n = list(map(int, input().split()))
print((n[0]*3+n[1])//2)
Buggy code:
a,p = map(int,input().split())
print((a+3*p)//2)

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

ans = 3 * a + p

ans = ans // 2

print(ans)
Buggy code:
import math
apple_one, apple_kakera = (int(i) for i in input().split())  
apple_kakera += apple_one * 3
print(math.floor(apple_one / 2) )

Fixed code:
import math
apple_one, apple_kakera = (int(i) for i in input().split())  
apple_kakera += apple_one * 3
print(math.floor(apple_kakera / 2) )
Buggy code:
A,P = map(int,input.split())

P += 3*A
print(P//2)

Fixed code:
A, P = map(int, input().split())

ans = (A * 3 + P) // 2

print(ans)
Buggy code:
A,P = map(int,input().split())
clc = A*3 + P
print(clc/2)

Fixed code:
A,P = map(int,input().split())
clc = A*3 + P
print(clc//2)
Buggy code:
a,p=int(input().split())
print((3*a+p)//2)

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

p += a*3

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

Fixed code:
a,b = map(int,input().split())
apple_pie = (a*3 + b) //2
print(apple_pie)
Buggy code:
A, P = map(int, input().split())

APPLE = 3*A + P

if APPLE % 2 = 0:
  ans = APPLE/2
else:
  ans = (Apple-1)/2

Fixed code:
A, P = map(int, input().split())
 
Apple = 3*A + P
 
if Apple % 2 == 0:
  ans = Apple/2
else:
  ans = (Apple-1)/2
 
print(int(ans))
Buggy code:
    a, p =map(int, input().split())
    print((3*a + p)//2)

Fixed code:
a, p = map(int, input().split())
print((p+3*a) //2)
Buggy code:
a, p = map(int, input().split())
print(int((3*a)/2))

Fixed code:
a, p = map(int, input().split())
p += 3 * a
print(p // 2)
Buggy code:
a,p=map(int,input().split());print((3*a+2*p)//2)


Fixed code:
a,p=map(int,input().split());print((3*a+p)//2)
Buggy code:
a,p=map(int(input().split()))
x=3*a+p
print(x//2)

Fixed code:
a,p=map(int,input().split())
x=3*a+p
print(x//2)
Buggy code:
import math
A, P = map(int, input().split())

print(math.ceil((P+3*A)/2))

Fixed code:
import math
A, P = map(int, input().split())

print(math.floor((P+3*A)/2))
Buggy code:
a,p=map(int,input().split())
print((a*3+p)//2))

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

ans = (a*3 + p) //2

print(ans)
Buggy code:
A, P = map(int, input().split())
print((A + 3*P) // 2)

Fixed code:
A, P = map(int, input().split())

ans = (3 * A + P) // 2

print(ans)
Buggy code:
A, P = map(int, input().split())
print((int((3*A)+P)/2))


Fixed code:
A, P = map(int, input().split())
piece = A*3 + P

print(piece // 2)
Buggy code:
a,p = map(int,input().split()
print((a*3+p)/2

Fixed code:
a, p = list(map(int, input().split()))
print((a*3 + p) // 2)
Buggy code:
A,N = map(int,input().split())


print((A//3)+N//2)




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


print((A*3+N)//2)
Buggy code:
A,P = map(int,input().split())
print(int((A*3*2+P)/2))

Fixed code:
A, P  = map(int, input().split())
print((A*3+P)//2)
Buggy code:
a,p=map(int,input().split())
int((3 * a + p) / 2)

Fixed code:
a,p = map(int,input().split())
print((a * 3 + p) // 2)
Buggy code:
A,P = map(int,input().split());print(A*3//2)

Fixed code:
A,P = map(int,input().split());print((A*3+P)//2)
Buggy code:
import math
A,P = map(int, input().split())
print(int(math.ceil((3*A+P)/2)))

Fixed code:
import math
A,P = map(int, input().split())
print(int(math.floor((3*A+P)/2)))
Buggy code:
import numpy as np
A,P = map(int, input().split())
print(int(np.ceil((3*A+P)/2)))

Fixed code:
import numpy as np
A,P = map(int, input().split())
print(int(np.floor((3*A+P)/2)))
Buggy code:
apple, peace = map(int, input().split())
print(apple * 3 + peace //3)

Fixed code:
apple, peace = map(int, input().split())
print((apple * 3 + peace) // 2)
Buggy code:
# input
A, P = map(int, input().split())
print(3 * A + P // 2)

Fixed code:
A, P = map(int, input().split())
print((3* A + P)//2)
Buggy code:
a,p = input().split()
int(a)
int(p)
print((a*3+p)//2)

Fixed code:
a,p=map(int,input().split())
print((a*3+p)//2)
Buggy code:
import math
a,p=map(int,input().split())
f=a*3
print(math.floor(f/2))

Fixed code:
import math
a,p=map(int,input().split())
f=a*3
print(math.floor((f+p)/2))
Buggy code:
x = input().split(" ")
a = int(x[0])
b = int(x[1])

r = a * 3 + b

print(r // 3)

Fixed code:
x = input().split(" ")
a = int(x[0])
b = int(x[1])

r = (a * 3) + b

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

Fixed code:
a, b = list(map(int, input().split()))
print((a*3+b)//2)
Buggy code:
a,p=map(int,input().split())
ap=(a*3+p)
if ap%2==0:
    print(ap/2)
else:
    print((ap-1)/2)

Fixed code:
a,p=map(int,input().split())
ap=(a*3+p)
if ap%2==0:
    print(int(ap/2))
else:
    print(int((ap-1)/2))
Buggy code:
print((lambda x,y:(x*3+y)//3)(*map(int, input().split())))

Fixed code:
print((lambda x,y:(x*3+y)//2)(*map(int, input().split())))
Buggy code:
x, y = map(int, input().split())
apple_piece_num = 3*x + y
valid_pie_num = apple_piece_num / 2
print(valid_pie_num)

Fixed code:
x, y = map(int, input().split())
apple_piece_num = 3*x + y
valid_pie_num = apple_piece_num // 2
print(valid_pie_num)
Buggy code:
A, P = map(int, input().split())
print((A // 3 + P) // 2)

Fixed code:
A,P = map(int,input().split())

P = P + A*3

print(P//2)
Buggy code:
A,P = map(int, input().split())

print((A//3+P)//2)

Fixed code:
A, P = map(int, input().split())
print((3 * A + P)//2)
Buggy code:
arguments = input("test")
arguments_as_list = arguments.split(" ")
list_to_integer = list(map(int, arguments_as_list))
apples_pieces = list_to_integer[0]*3
pieces = list_to_integer[1]


print(int((apples + pieces)//2))



Fixed code:
arguments = input()
arguments_as_list = arguments.split(" ")
list_to_integer = list(map(int, arguments_as_list))
apples_pieces = list_to_integer[0]*3
pieces = list_to_integer[1]


print(int((apples_pieces + pieces)//2))
Buggy code:
a, b=map(int,input().split()) 
print((a*3+b)/2)

Fixed code:
a,b = map(int,input().split())
print((a*3+b)//2)
Buggy code:
A, P = map(int, input().split())
print((2*A+P)//2)

Fixed code:
A, P = map(int, input().split())
print((A*3 + P) // 2 )
Buggy code:
a,p =map(int,input().split())
b = (3*a + P) // 2
print(b)

Fixed code:
a,p =map(int,input().split())
b = (3*a + p) // 2
print(b)
Buggy code:
A, P = map(int, input().split())
print((3*A+P)//2)Ｖ

Fixed code:
A, P = map(int, input().split())
print( (3*A+P)// 2)
Buggy code:
a,p=map(int,input().split())
print((a*3+p)/2)

Fixed code:
a, p = map(int, input().split())
print ((a * 3 + p) // 2)
Buggy code:
a,p=[int(i)for i in input().split()]
apple=a+p//3
print(apple//2)

Fixed code:
a,p=[int(i)for i in input().split()]
apple=3*a+p
print(apple//2)
Buggy code:
A,P=map(int,input().split())
print((A*3+P)/2)

Fixed code:
A, P=map(int, input().split())
print((A * 3 + P) // 2)
Buggy code:
a,p=map(int,input().split());print(a*3+p//2)

Fixed code:
a, p = map(int, input().split())
print((p + a*3)//2)
Buggy code:
import math

A, P =map(int,input().split())
print(A , P)

x = 3*A + P

print(math.floor(x/2))

Fixed code:
import math

A, P =map(int,input().split())
#print(A , P)

x = 3*A + P

print(math.floor(x/2))
Buggy code:
input_AP = list(map(int, input().split()))
A = input_AP[0]
P = input_AP[1]

result = A*3//2

Fixed code:
input_AP = list(map(int, input().split()))
A = input_AP[0]
P = input_AP[1]

result = (A*3 + P)//2
print(result)
Buggy code:
a,p = map(int, input().split())
b = a*2+p
print(b//2)

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

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

result = (a*3+p)//2

print(result)
Buggy code:
A, P = map(int, input().input())
print((A * 3 + P)//2)

Fixed code:
A, P = map(int, input().split())
print((A * 3 + P)//2)
Buggy code:
import sys

a, p = map(int, sys.stdin.readlines()[0].strip)
print((p + a * 3) // 2)

Fixed code:
import sys

a, p = map(int, sys.stdin.readlines()[0].strip().split())
print((p + a * 3) // 2)
Buggy code:
w = input()
s = w.split()

apple = int(s[0])
piece = int(s[1])


answer = ( 3 * apple + piece - (( 3 * apple + piece ) % 2 ) /2

print(answer)

Fixed code:
w = input()
s = w.split()

apple = int(s[0])
piece = int(s[1])


answer = int(( 3 * apple + piece - (( 3 * apple + piece ) % 2 )) /2)

print(answer)
Buggy code:
a,p=map(int,input().split())
s=3*a+p
if s%2==0:
  print(s/2)
else:
  print((s-1)/2)

Fixed code:
a,p=map(int,input().split())
s=3*a+p
if s%2==0:
  print(int((s/2)))
else:
  print(int(((s-1)/2)))
Buggy code:
A, P = map(int, input().split())
ans = (A+3 + P) // 2
print(ans)

Fixed code:
A, P = map(int, input().split())
ans = (A*3 + P) // 2
print(ans)
Buggy code:
a,p = map(int,input().split())
print(int(a*3+p)/2)


Fixed code:
#a
a,p = map(int,input().split())
p += a*3
print(p//2)
Buggy code:
i = list(map(int, input().split())) 
Apple = 3 * i[0] + i[1]
Apple//2

Fixed code:
i = list(map(int, input().split())) 
Apple = 3 * i[0] + i[1]
print(Apple//2)
Buggy code:
import math
a,p=map(int.input().split())
p=p+a*3
print(math.floor(p/3))

Fixed code:
import math
a,p=map(int,input().split())
p=p+a*3
print(int(math.floor(p/2)))
Buggy code:
A,P=map(int(input().split()))
print(((A*3)+P)//2)

Fixed code:
A,P = map(int,input().split())
print((A*3+P) // 2)
Buggy code:
a,p=map(int,input().split())

a_p=a*3
p_total=a_p+p
print(p_total//3)

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

a_p=a*3
p_total=a_p+p
print(p_total//2)
Buggy code:
a, p = map(int, input().split())
print((a*3+p)//3)

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

print((3*a + p) // 2)
Buggy code:
a,p=map(int,input().split(' '))
print(int((3*a+p)/2)

Fixed code:
a,p = map(int, input().split())
print((a*3+p)//2)
Buggy code:
A,P=map(int,input().split())

print((A*3+P)/2)

Fixed code:
A,P=map(int,input().split())

a=A*3
a=a+P
print(a//2)
Buggy code:
a, p = map(int(), input().split())

print(int((a * 3 + p) / 2))

Fixed code:
a,p=map(int,input().split())
print((a*3+p) // 2 )