Problem:
 Score : 100 points    Problem Statement We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.      Constraints  All values in input are integers.  0 \leq A, P \leq 100         Input Input is given from Standard Input in the following format:  A  P       Output Print the maximum number of apple pies we can make with what we have.        Sample Input 1 1 3      Sample Output 1 3  We can first make one apple pie by simmering two of the three pieces of apple. Then, we can make two more by simmering the remaining piece and three more pieces obtained by cutting the whole apple.       Sample Input 2 0 1      Sample Output 2 0  We cannot make an apple pie in this case, unfortunately.       Sample Input 3 32 21      Sample Output 3 58

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

Solution (Python):
A,P=[int(x) for x in input().split()]
out=int((A*3+P)/2)

print(out)

Solution (Python):

lst_1 = input().split()

A = int(lst_1[0])
P = int(lst_1[1])

piece = A * 3

piece += P

pie = piece // 2

print(pie)

Solution (Python):
a, p = map(int, input().split())

kakera = 3 * a + p
pie = kakera // 2
print(pie)

Solution (Python):
if __name__ == '__main__':
    A, P = map(int, input().split())

    P += 3 * A

    print(str(P//2))

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

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

Solution (Python):
a,p = map(int, input().split())


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

Solution (Python):
import math
a, p = map(int, input().split())
print (math.floor((a*3+p)/2))

Solution (Python):
def input_from_console():
    a, p = map(int, input().split())
    return a, p


def solve(a, p):
    import math
    total_slice = a * 3 + p
    result = math.floor(total_slice / 2)
    return result


def main():
    a, p = input_from_console()
    print(solve(a, p))


if __name__ == "__main__":
    import sys

    if sys.gettrace():  
        check_cases()
    else:
        main()

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

Solution (Python):
A,P = map(int, input().split())
 
a = int(A*3)
 
ans = int((a + P)/2)
 
print(ans)

Solution (Python):
a, p = list(map(int, input().split()))
total = p + (a*3)
print(total // 2)

Solution (Python):
from sys import stdin


a, p = [int(x) for x in stdin.readline().rstrip().split()]

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

print(ans)

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

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

Solution (Python):


import sys
import math
import collections

A,P = map(int, sys.stdin.readline().rstrip().split(" "))
P = P + A*3
print(P//2)
exit(0)

Solution (Python):
def main():
    a, p = map(int, input().split())

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

if __name__ == "__main__":
    main()

Solution (Python):
a,p = map(int,input().split())
b = a * 3
ps = b + p
print(int(ps / 2))

Solution (Python):
a, p = map(int, input().split())

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

Solution (Python):

A,B=map(int, input().split())
A_piece = (A * 3) + B
ApplePie = A_piece//2
print(ApplePie)

Solution (Python):
x=input()
xx=x.split()
A=int(xx[0])
P=int(xx[1])
a=(A*3+P)/2
print(int(a))

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

Solution (Python):
class ApplePie:
    def __init__(self):
        self.A, self.P = map(int, input().split())

    def makePie(self):
        piece = self.P + self.A * 3
        print(piece // 2)


applePie = ApplePie()
applePie.makePie()

Solution (Python):
A, P = [int(x) for x in input().split(' ')]
pies = (A * 3 + P) // 2
print(pies)

Solution (Python):
l = list(map(int,input().split()))

print(int((l[0]*3+l[1])/2))

Solution (Python):
a,p=map(int,input().split())
total=a*3+p

print(total//2)

Solution (Python):
A, P = list(map(int, input().split()))
print(int((A*3+P)/2))

Solution (Python):
a,p=list(map(int,input().split()))
print((3*a+p)//2)

Solution (Python):
A, P = input().split()

a = int(A)
p = int(P)
apple = int((a*3 + p) / 2)

print(apple)

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

Solution (Python):
A, P = map(int, input().split())

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

Solution (Python):
a,b=map(int,input().split())
n=int((a*3+b)/2)
 
print(n)

Solution (Python):
A, P = list(map(int, input().split()))

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

Solution (Python):
from math import floor
a,p=map(int,input().split())
piece=p+3*a
print(floor(piece/2))

Solution (Python):
a, p = map(int,input().split())

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

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

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

Solution (Python):
A,P=(int(x) for x in input().split())

chip = 3*A + P
import math
ans = math.floor(chip/2)
print(ans)

Solution (Python):
A, P = map(int, input().split())
sum = A * 3 + P
pie = int(sum / 2)
print(pie)

Solution (Python):
A,P = list(map(int,input().split()))
print(int((3*A+P)/2))

Solution (Python):

N = input()
mapped_A  = map(int, N.split())
A,P =  list(mapped_A)
kakera = A*3+P
print(int(kakera/2))

Solution (Python):
N, M = map(int, input().split())
print(int((N*3+M)/2))

Solution (Python):
import sys

fin = sys.stdin.readline
A, P = [int(elem) for elem in fin().split()]

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

Solution (Python):

"""
Created on Sun May 26 21:02:44 2019

@author: aono
"""

s = input().split()

s = [int(v) for v in s]

apple = s[0]
apple_pieces = s[1]

apple_pieces = apple_pieces + 3*apple
apple_pies = int(apple_pieces / 2)

print(apple_pies)

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

Solution (Python):

import sys


def solve(A: int, P: int):
    P += A * 3
    print(int(P / 2))
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    P = int(next(tokens))  
    solve(A, P)

if __name__ == '__main__':
    main()

Solution (Python):

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

totalpiece = A * 3 + P


print(int(totalpiece / 2))

Solution (Python):
A, P = map(int,input().split())

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

Solution (Python):
a,b=map(int, input().split())
c = a * 3 +b
print(c//2)

Solution (Python):


from collections import deque
import itertools as ite
import sys
import math

sys.setrecursionlimit(1000000)

INF = 10 ** 18
MOD = 10 ** 9 + 7

A, P = map(int, raw_input().split())
print (A * 3 + P) / 2

Solution (Python):
A, P = input().split()
A = int(A)
P = int(P)

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

Solution (Python):
import math

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

Solution (Python):
A, P = map(int, input().split())

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

Solution (Python):
a, p = map(int, input().split())

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

Solution (Python):
a, p = map(int, input().split())

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

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

Solution (Python):
s = input().split()
A = int(s[0])
P = int(s[1])

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

Solution (Python):
AP = [int(i) for i in input().split()]
apple = AP[0] * 3 + AP[1]
answer = int(apple/2)
print(answer)

Solution (Python):
import math
a,p = map(int,input().split())
p = a*3 + p

print(math.floor(p/2))

Solution (Python):
A, P = map(int, input().split())

S = A * 3 + P

print(S // 2)

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

Solution (Python):
A, P = list(map(int, input().split()))
P += A * 3

print(P // 2)

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

Solution (Python):
def solve():
    a, p = map(int, input().split())
    p += (a*3)
    pie = p / 2
    print(int(pie))

if __name__ == "__main__":
    solve()

Solution (Python):
A, P = (int(x) for x in input().split())

B = int(A*3)
C = int((B+P)/2)

print(C)

Solution (Python):


a,p = [int(i) for i in input().split()]


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

Solution (Python):


import sys
input = sys.stdin.readline



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


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

Solution (Python):
def main():
    line = input()
    a, p = line.split(" ")
    p = int(p)
    p += int(a) * 3
    pi = p // 2
    print(pi)


if __name__ == '__main__':
    main()

Solution (Python):
(a,p) = map(int,input().split())

n = 3 * a + p

x = n // 2

print(x)

Solution (Python):
a,p=map(int,input().split(" "))
print(int((a*3+p)/2))

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

Solution (Python):
import math
data = list(map(int,input().split()))
print(math.floor((data[0]*3+data[1])/2))

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

Solution (Python):
A, P = map(int, input().split())

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

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

Solution (Python):
A, P = (int(i) for i in input().split())

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

Solution (Python):
a, p = map(int, input().split())

piece = a * 3 + p
pie = piece / 2

print(int(pie))

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

Solution (Python):
A,P=map(int,input().split())

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

Solution (Python):
A, P = map(int, input().split(" "))
print((3 * A + P) // 2)

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

Solution (Python):
a,p = map(int,raw_input().split())
print (3*a+p)/2

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

Solution (Python):
x = list(map(int, input().split()))
a,p = x[0],x[1]
print((3*a + p)//2)

Solution (Python):
A, P = list(map(int, input().split()))

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

Solution (Python):
A, P = map(int, input().split())
X = (3*A + P) // 2
print(X)

Solution (Python):
A, P = map(int, input().split())

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

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

Solution (Python):
import math

input_a, input_p = map(int, input().split())
print(math.floor((input_a * 3 + input_p)/2))

Solution (Python):
A, P = list(map(int, input().split()))

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

Solution (Python):
A,P=map(int,input().split())

pi=int((A*3+P)/2)

print(pi)

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

Solution (Python):
import sys
input=sys.stdin.readline
from collections import deque
from heapq import heappush,heappop
import re

def int_raw():
    return int(input())
 
def ss_raw():
    return input().split()
 
def ints_raw():
    return tuple(map(int, ss_raw()))

def main():
    N,P = ints_raw()
    return (N*3+P)//2

print(main())

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

Solution (Python):
def solve():
    A, P = map(int, input().split())
    
    print ((A*3 + P)//2)
    
if __name__ == "__main__":  
    solve()

Solution (Python):
import sys
input = sys.stdin.readline
a,p = map(int,input().split())
ans = (3*a + p)//2
print(ans)

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

Solution (Python):
A, P = map(int, input().split())

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

Solution (Python):
import math
a,p = map(float,input().split())
p+=a*3
print(math.floor(p/2))

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

Solution (Python):
A,P = map(int,input().split())

K = 3*A

total = K + P

pi = int((K + P)/2)
print(pi)

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

Solution (Python):
A, P = map(int, input().split())

a = A * 3 + P

print(int(a // 2))

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

Solution (Python):
A, P = map(int, input().split())

P2 = A*3

print(int((P + P2)/2))

Solution (Python):
a, p = map(int, input().split())
b = a * 3
pie = int((b + p) / 2)

print(str(pie))

Solution (Python):

def main():
    A,P = map(int,input().split())
    A = A*3
    pi = int((A+P)/2)
    print(pi)
if __name__ == '__main__':
    main()

Solution (Python):
a, p = list(map(int, input().split()))
print(int((a*3+p)/2))

Solution (Python):
inp = input()
st = inp.split()
a = int(st[0])
p = int(st[1])
p += a*3
ans = int(p / 2)
print(ans)

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

Solution (Python):
a,p = list(map(int,input().split()))
ans = (a*3+p)
if ans % 2 == 0:
    print(int((ans)/2))
else:
    print(int((ans-1)/2))

Solution (Python):
if __name__ == '__main__':
    s = input().rstrip().split(' ')

    A = int(s[0])
    P = int(s[1])
    
    print(int((A*3+P)/2))

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

Solution (Python):
x,y = map(int,input().split())
n = (3*x+y)/2
print(int(n))

Solution (Python):
A,P=map(int,input().split())

num=A*3+P

num=num//2

print(num)

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

Solution (Python):
I=lambda:map(int,input().split())
A,P=I()
print((A*3+P)//2)

Solution (Python):
A, P = [int(ap) for ap in input().split()]
K = A * 3 + P
print(K // 2)

Solution (Python):
A,P = map(int,input().split())

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

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

print(piece // 2)

Solution (Python):
A, P = map(int, input().split())

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

Solution (Python):
A,P = map(int,input().split())

P += 3*A

print(P//2)

Solution (Python):
A, P = map(int, input().split())

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

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

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

Solution (Python):
a, p = map(int, input().split())
p += a * 3
ans = p // 2
print(ans)

Solution (Python):
a = input().split()
a = [int(f) for f in a]

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

Solution (Python):
A,P = list(map(int,input().split()))
P = P + 3*A
print(P // 2)

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

Solution (Python):
A, P = map(int, input().split())
sum=A*3+P
print(sum//2)

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

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

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

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

Solution (Python):
a,p = [int(x) for x in input().split()]

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

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

Solution (Python):
A, P = map(int, input().split())
Answer = (3*A + P)//2
print(Answer)

Solution (Python):
a, p = map(int, input().split())
ret = (a*3) + p
print(ret//2)

Solution (Python):
a, p = map(int, input().split())
ans = (a * 3 + p) // 2
print(int(ans))

Solution (Python):




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


if __name__ == '__main__':
	import sys
	sys.exit(main())

Solution (Python):


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

Solution (Python):
def main():
    A, P = map(int, input().split())

    print("{}".format((A*3+P)//2))


if __name__ == "__main__":
    main()

Solution (Python):
a, p = (int(i) for i in input().split())

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

Solution (Python):
A, P = [int(_) for _ in input().split()]

P += 3 * A

print(P // 2)

Solution (Python):
a,p = map(int, input().split())
ans = ( a * 3 + p )//2
print(ans)

Solution (Python):
a,p = map(int,input().split())

p = p + a * 3

print(p // 2)

Solution (Python):
A, P = map(int, input().split())

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

Solution (Python):
N,P=[int(x) for x in input().split()]

A=N*3+P

print(int(A/2))

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

Solution (Python):
a,p=(int(i) for i in input().split())
v=(3*a+p)//2
print(v)

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

Solution (Python):
a,p = map(int,input().split())
ans = (a * 3 + p)// 2
print(ans)

Solution (Python):
import math
a, p = map(int, input().split())
print(math.floor((3*a+p)/2))

Solution (Python):
a, p = (int(i) for i in input().split())

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

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

Solution (Python):
A,P = map(int, raw_input().split())
P = P + A*3
print(P/2)

Solution (Python):

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

p = p+a*3

print(p//2)

Solution (Python):
def solve():
  A, P = map(int, input().split())
  return (A * 3 + P) // 2

print(solve())

Solution (Python):
A,P = map(int,input().split())
P += A*3

answer = P//2
print(answer)

Solution (Python):
A,P = input().split()
A = int(A)
P = int(P)
p = A*3 + P
p_num = p //2
print(p_num)

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


if __name__ == "__main__":
    main()

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

Solution (Python):
A, P = map(int, input().split())

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

Solution (Python):






import sys
input = sys.stdin.readline
A, B = map(int, input().split())





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

Solution (Python):
inp = input()
a = int(inp.split()[0])
p = int(inp.split()[1])

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

print(ans)

Solution (Python):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
Max = sys.maxsize
def l():
	return list(map(int,input().split()))
def m():
	return map(int,input().split())
def s(x):
	a = []
	aa = x[0]
	su = 1
	for i in range(len(x)-1):
		if aa == x[i+1]:
			a.append([aa,su])
			aa = x[i+1]
			su = 1
		else:
			su += 1
	a.append([aa,su])
	return a
def jo(x):
	return " ".join(map(str,x))

a,p = m()

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

Solution (Python):

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

P=P+3*A

print(int(P/2))

Solution (Python):
A, P = map(int, input().split())

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

Solution (Python):
a,b = map(int,input().split())
a = 3*a
c = a + b
if c > 0:
    print(int(c/2))
else:
    print(0)

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

Solution (Python):
a, p = [int(i) for i in input().split()]
p += 3* a
print(p//2)

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

Solution (Python):
import math
apple = input().split()
ringo = int(apple[0])
kakera = int(apple[1])

print(math.floor((ringo * 3 + kakera) / 2))

Solution (Python):
A, P = map(int, input().split())
pice = A * 3 + P
pi = pice // 2
print(pi)

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

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

Solution (Python):
a,p = map(int,input().split())

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

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

Solution (Python):
A, P = list(map(int, input().split()))
print((3*A+P)//2)

Solution (Python):


A,P = [int(x) for x in input().split()]
print(int((3*A+P)//2))

Solution (Python):
inp = list(map(int, input().split()))
res=int((inp[0]*3+inp[1])/2)
print(res)

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

Solution (Python):


a,p = (int(i) for i in input().split()) 
piece=a*3+p
pie=int(piece/2)
print(pie)

Solution (Python):
A, P = map(int,input().split())

p = A*3 + P
result = int(p / 2)
print("{}".format(result))

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

Solution (Python):
from __future__ import print_function


import sys
input = sys.stdin.readline

def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)

import math
import string
import fractions
import re
import array
import copy
import functools
import operator

import collections
import itertools
import bisect
import heapq


from heapq import heappush
from heapq import heappop



import random


def main():
    n,p = map(int, input().split())
    print((int((n*3+p)/2)))



if __name__ == '__main__':
    main()

Solution (Python):
A,P = map(int,input().split())
Ap = A*3+P
print(Ap//2)

Solution (Python):
import math
a,p = map(int,input().split())
print(int(math.floor((p+a*3)/2)))

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

Solution (Python):
A, P = map(int, input().split())

piece = A * 3 + P

print(piece // 2)

Solution (Python):
a,b=map(int,input().split())
print((b+a*3)//2)

Solution (Python):
from sys import stdin

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

input = lambda: stdin.readline()
main()

Solution (Python):
a, p = map(int,(input().split()))
c = 3*a + p
print(c//2)

Solution (Python):
a,b = map(int,input().split())
x = (a*3) + b
print(x//2)

Solution (Python):
a, p = map(int, input().split())

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

Solution (Python):
A, P = [int(i) for i in input().split()]
print( (A*3+P) // 2)

Solution (Python):
A, P = map(int, input().split())

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

print(N)

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

Solution (Python):
A, P = [int(i) for i in input().split()]
print(int((3*A + P)/2))

Solution (Python):

i = list(map(int,input().split()))

kakera = (i[0] * 3) + i[1]
pie = int((kakera - kakera%2)/2)
print (pie)

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

Solution (Python):
A,P = map(int,input().split())
K = 3*A
P = P+K
print(P//2)

Solution (Python):
A, P = map(int, input().split())
S = A * 3 + P
print(S // 2)

Solution (Python):
i=list(map(int,input().split()))
print(int((3*i[0]+i[1])/2))

Solution (Python):
a=list(map(int,input().split(" ")))
print((a[0]*3+a[1])//2)

Solution (Python):
a,b=map(int,input().split())
print(((a*3)+b)//2)

Solution (Python):
import numpy as np

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

Solution (Python):
a,p = map(int, input().split())

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

print(ans)

Solution (Python):



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

p += 3*a

print(p//2)

Solution (Python):
a,p = list(map(int, input().split()))
print(int((a*3+p)/2))

Solution (Python):
A,P= map(int,input().split())

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

Solution (Python):
a,p = map(int, input().split())


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

Solution (Python):

import sys


def solve(A: int, P: int):
    print((3*A+P)//2)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    P = int(next(tokens))  
    solve(A, P)

if __name__ == '__main__':
    main()

Solution (Python):
from sys import stdin
import math
import itertools


def makeIntMatrix(lines):
    intMatrix = []
    for a in makeStringMatrix(lines):
        intMatrix.append([int(b) for b in a])
    return intMatrix
 
 
def makeStringMatrix(lines):
    stringMatrix = [line.split() for line in lines]
    return stringMatrix
 
 
def makeInt(line):
    return int(line.rstrip())
 
 
def makeMultiInteger(line):
    return [int(x) for x in line.rstrip().split()]


def solve(input_string):
    a, p = makeMultiInteger(input_string[0])
    
    p += a*3
    
    return p//2


def main():
    input_lines = stdin.readlines()
    answer = solve(input_lines)
    print(answer)


if __name__ == '__main__':
    main()

Solution (Python):
a, b = map(int, input().split())
ans = 0
b = b + a * 3
ans = b / 2
print(int(ans))

Solution (Python):

import sys;
import string;
sys.setrecursionlimit(20000) 

from functools import lru_cache







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



















def doit(n, s):
  if n < 2:
    return
  print(s, file=sys.stderr)

  last = n - 1
  for x in range(last):
    if qa(s[x], s[last]):
      swap = s[x]
      s[x] = s[last]
      s[last] = swap
  doit(last, s)

try:
  print ((a * 3 + p) // 2)

except Exception as e:
  print(e, file=sys.stderr)
  print(s)

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

Solution (Python):
a, p = map(int, input().split())

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

Solution (Python):
A,P = map(int, input().split())

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

print(ans)

Solution (Python):
a,p=map(int,input().split())
print( str(int((3*a+p) / 2)))

Solution (Python):
A, P = (int(x) for x in input().split())
print((3*A+P)//2)

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

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

Solution (Python):
n,k = map(int,input().split(' '))
A = n*3+k
print(A//2)

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

Solution (Python):
A,P = list(map(int, input().split()))
print((A * 3 + P) //2)

Solution (Python):
a, p = map(int, input().split())

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

Solution (Python):
import sys
sys.setrecursionlimit(1000000)
 
A,P = map(int,input().split())

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

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

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

Solution (Python):
A,P = map(int,input().split(' '))
X = ((A*3) + P) // 2
print(int(X))

Solution (Python):
a,b=map(int,input().split())
b+=a*3
print(int(b/2))

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

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

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

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

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

Solution (Python):
A, P = map(int, input().split())

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

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

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

Solution (Python):
a, p=map(int, input().split())
all_count=a*3+p
print(all_count//2)

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

Solution (Python):
if __name__ == '__main__':
    inp = input().split(' ')
    a = int(inp[0])
    p = int(inp[1])
    print(str((a * 3 + p) // 2))

Solution (Python):
a,p = map(int, input().split())


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

Solution (Python):
N,M = input().split()
N = int(N)
M = int(M)

sum = N*3 + M
pie = sum//2

print(pie)

Solution (Python):
read = input
A,P = map(int, read().split())
pieces = A * 3 + P
pie = pieces//2
print(pie)

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

Solution (Python):
A,P = map(int,input().split())

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

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

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

Solution (Python):
A,P = map(int,input().split())

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

Solution (Python):
A,P = map(int, input().split())

pie = int((A * 3 + P) / 2)

print(pie)

Solution (Python):
A, P = map(int, input().split(" "))
a = A * 3
k = a + P
ans = int(k * 0.5)
print(ans)

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

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

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

Solution (Python):
A,P = map(int, input().split())

print('{}'.format((3*A+P)//2))

Solution (Python):
a,b = map(int,input().split())
print((3*a+b)//2)

Solution (Python):
A, P = list(map(int, input().split()))
print((3 * A + P) // 2)

Solution (Python):
a,p=[int(_) for _ in input().split()]
print((a*3+p)//2)

Solution (Python):
A,P = input().split()
pie = (int(P)+int(A)*3) // 2
print(pie)

Solution (Python):
a,p=map(int,input().split())
sum_p=a*3+p
print(int(sum_p//2))

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

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

Solution (Python):




def main():
  a, p = map(int, input().split())

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


if __name__ == '__main__':
  main()

Solution (Python):
A, P =map(int, input().split())
a = (A*3 + P)//2
print(a)

Solution (Python):
A,P = map(int, input().split())

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

print(ans)

Solution (Python):
a, p = map(int,input().split())

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

Solution (Python):
a, p = map(int, input().split())
ans = (a * 3 + p)/2
print(int(ans))

Solution (Python):
import math


def main():
    A, P = map(int, input().split())

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


if __name__ == '__main__':
    main()

Solution (Python):
a, p = map(int, input().split())
x = 3 * a + p
print(x // 2)

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

Solution (Python):
apple, piece = input().split(" ")
crushed_piece = int(apple) * 3 + int(piece)
print(crushed_piece//2)

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

Solution (Python):
ap = input().split()
a = int(ap[0])
p = int(ap[1])
k = 3*a + p
aa = k // 2
print(aa)

Solution (Python):
A, P = map(int, input().split())
P = A*3 + P

print(P//2)

Solution (Python):
A,P = list(map(int,input().split()))
kakera = A*3+P
print(int(kakera/2))

Solution (Python):
a, p = list(map(int, input().split()))
print((a*3+p)//2)

Solution (Python):
A, P = list(map(int, input().split()))
print((A*3+P)//2)

Solution (Python):
a,p=map(int,input().split())
s = 3*a + p
print(int(s/2))

Solution (Python):
a,b=map(int, input().split()) 
print((a*3+b)//2)

Solution (Python):




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

piece = 3 * a + p
pi = int(piece / 2)

print(pi)

Solution (Python):

import sys

import heapq
import re
import bisect
import random
import math
import itertools
from collections import defaultdict, deque
from copy import deepcopy
from decimal import *

readl= lambda: list(map(int, sys.stdin.readline().split()))
readt= lambda: tuple(map(int, sys.stdin.readline().split()))
read = lambda: sys.stdin.readline().rstrip()
readi = lambda: int(read())
readmi = lambda: map(int, sys.stdin.readline().split())
readms = lambda: map(str, sys.stdin.readline().split())

a, b = readmi()
print((a * 3 + b) // 2)

Solution (Python):
A, P = [int(i) for i in input().split()]
X = (A*3 + P) // 2
print(X)

Solution (Python):
A,P=[int(i) for i in input().split()]
B = 3*A
print((P+B)//2)

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()

mi = lambda: map(int, input().split())

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

Solution (Python):










import numpy as np
import math
import copy

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

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

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

Solution (Python):

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

kakera = A*3 + P
ans = int(kakera//2)
print(str(ans))

Solution (Python):
a,b=map(int,input().split())
print((3*a+b)//2)

Solution (Python):
A, P = map(int, raw_input().split())
print (A*3+P)/2

Solution (Python):
a, b = map(int, input().split())

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

Solution (Python):
A, B = map(int, input().split())

x = A * 3
y = x + B

print(int(y / 2))

Solution (Python):
N,M=map(int ,raw_input().split())
a = (3*N+M)//2
print (a)

Solution (Python):
A,P = map(int, input().split())

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

Solution (Python):
a,p = map(int, input().split())

b = a*3 + p

ans = int(b/2)
print(ans)

Solution (Python):
a,p=map(int,input().split())

p1=p+(3*a)

print(p1//2)

Solution (Python):
A,P=map(int,input().split())
X=(A*3)+P
Y=X//2
print(Y)

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

Solution (Python):
A,P=[int(i) for i in input().split(" ")]
print((3*A+P)//2)

Solution (Python):

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

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

Solution (Python):
apple, piece = map(int,input().split())

ans = (apple * 3 + piece) // 2

print(ans)

Solution (Python):
a,b = list(map(int, input().split()))

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

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