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

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

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

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

print(P // 2)

Solution (Python):
A,N = map(int,input().split())
print((3*A+N)//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())

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

Solution (Python):
a, p = [int(n) for n 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())
a = A * 3 + P
pie = a // 2
print(int(pie))

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

main()

Solution (Python):

import sys

s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    A, P = i2nn()
    n = A * 3 + P
    print(n // 2)

main()

Solution (Python):

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

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

Solution (Python):
import sys

from fractions import gcd





from itertools import accumulate













input = sys.stdin.readline
def ii(): return int(input())
def mi(): return map(int, input().rstrip().split())
def lmi(): return list(map(int, input().rstrip().split()))
def li(): return list(input().rstrip())



def iterate_tokens():
    for line in sys.stdin:
        for word in line.split():
            yield word


if __name__ == '__main__':

    tokens = iterate_tokens()
    A = int(next(tokens))  
    P = int(next(tokens))  

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

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

Solution (Python):



v = list(map(int, input().split()))
a, p = v[0], v[1]

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

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

Solution (Python):
apple,apple_piece = input().split()
apples = int(apple) * 3 + int(apple_piece)
apple_pie = apples // 2
print(apple_pie)

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

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

aa = a * 3
print(int((aa + 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):
S = input()
A,P = S.split(' ')
print( (int(A)*3+int(P))//2 )

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

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

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

print(N)

Solution (Python):
import sys
stdin = sys.stdin
 
sys.setrecursionlimit(10**5) 
 
def ii(): return int(stdin.readline())
def li(): return map(int, stdin.readline().split())
A, P = tuple(li())
ps = A * 3 + P
print(ps // 2)

Solution (Python):
A,P = map(int, input().split())
pie = A*3+P
print(round(int(pie/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):
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=list(map(int,input().split()))
print(((a*3)+p)//2)

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

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

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

B = 3*A

ans = (B+P) // 2

print(ans)

Solution (Python):
import math
import sys
sys.setrecursionlimit(10 ** 6 + 10)
from collections import defaultdict




def main():
    a, b = map(int, input().split())
    b += 3 * a

    print(b // 2)




if __name__ == '__main__':
    main()

Solution (Python):
from itertools import product
import bisect
import sys


def input():
    return sys.stdin.readline()[:-1]


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()
apple_piece = 3*int(s[0])+int(s[1])
print(apple_piece//2)

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

p += a*3

print(p//2)

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

Solution (Python):
a, p = [int(v) for v 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 = [int(x) for x in 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 = list(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())
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((a*3+p)//2)

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

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

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

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

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

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

print(total)

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

SUM = a * 3 + p

print(int(SUM / 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 = map(int,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,input().split())

piece = a*3 + p

pie = piece//2

print(pie)

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

Solution (Python):
import sys
def a():
    p = [[int(t) for t in r.split(' ')] for r in sys.stdin.read().split('\n') if r != '']
    A, P = p[0]
    print(int((A*3+P)/2))
a()

Solution (Python):
A, P = list(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())

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

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

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

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

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

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

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

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

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

Solution (Python):
A,P = 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=map(int,input().split())
print((a*3+p)//2)

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

Solution (Python):



a,p = input().split()

a = int(a)
p = int(p)

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

Solution (Python):
import math

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

c=math.floor(int((3*aa+bb)/2))
print(c)

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

piece = A * 3 + P
result = math.floor(piece / 2.0)

print(int(result))

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

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

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

print(int(piece / 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())
print((P+3*A)//2)

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

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

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

Solution (Python):
a = (input().split())

x=int(a[0])*3
y=int(a[1])

z=x+y

print(z//2)

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

ringo = a * 3  + b
pai = ringo // 2


print(pai)

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

Solution (Python):
from sys import stdin
import numpy as np

A, P = [int(x) for x in stdin.readline().rstrip().split()]

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

Solution (Python):
def InputToInt():
    A = input().split()
    for i in range(len(A)):
        A[i] = int(A[i])
    return A
    
if __name__ == '__main__':
    N, M = InputToInt()
    print(int((N*3+M)/2))

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


main()

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

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

print(ans)

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

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

Solution (Python):
def pie(A, P):
    P_cra = A*3
 
    P_all = P_cra + P
 
    pie = P_all//2
 
    print(pie)

l = list(map(int, input().split()))
A = int(l[0])
P = int(l[1])
pie(A, P)

Solution (Python):
def run(A, P):
    return (A*3 + P)//2


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


if __name__ == '__main__':
    main()

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

Solution (Python):
import sys
rr = lambda: sys.stdin.readline().strip()
rri = lambda: int(rr())
rrs = lambda: [int(_) for _ in rr().split()]

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

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

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

Solution (Python):




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


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


print(ans)

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

Solution (Python):
args = input().split()
A, P = int(args[0]), int(args[1])
sum = A * 3 + P
result = sum // 2
print(result)

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

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

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

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

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

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

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

Solution (Python):

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


P += A*3

print(int(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 = input().split()
A, P = int(A), int(P)

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

Solution (Python):
import math

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

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

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

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

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

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

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

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

print(pie)

Solution (Python):








lis=list(map(int,input().split()))
ans=lis[0]*3+lis[1]
ans=ans-ans%2
ans=int(ans/2)

print(ans)

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

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

Solution (Python):
def inpl():
    return list(map(int, input().split()))


A, P = inpl()

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())
pie = (A*3 + P)//2
print(pie)

Solution (Python):



def readInt():
    return int(input())

def readList():
    return list(input().split())

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

def main():
    a, p = readListI()
    print((a*3+p) // 2)


if __name__ == '__main__':
    main()

Solution (Python):
A, P = map(int, input().split())
print((3 * A + P)//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())
print((a * 3 + p) // 2)

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

P += 3 * A



ans = int(P // 2)

print(int(ans))

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

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

print(apple_pi)

Solution (Python):
import sys
sys.setrecursionlimit(10**7)






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

    n_frac = a * 3 + p
    n_pi = n_frac // 2
    print(n_pi)
solve()

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

Solution (Python):
import math

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

print(math.floor((a*3 + b) /2))

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

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

Solution (Python):

import sys
INF = float("inf")


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):
import sys

a,p = input().split()

a,p = int(a), int(p)

print(int((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((3*a+p)//2)

Solution (Python):
a,b=map(int,input().split())
print((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())
P += A * 3
print(P // 2)

Solution (Python):

INPUT = input().split()

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

crashApple = A * 3

fff = crashApple + P

print(fff // 2)

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

Solution (Python):

input_data = input().split()
a = int(input_data[0])
p = int(input_data[1])

ans = int(((a * 3) + 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((a*3+p)//2)

Solution (Python):

"""
Created on Sun May 26 21:04:24 2019

@author: yuta
"""

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

def main(a,p):
    pie = (3*a + p )/2
    print(int(pie))

main(A,P)

Solution (Python):


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

Solution (Python):
a,b=(int(x) for x in input().split())

x= int(((a*3 +b) /2))

print (x)

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

Solution (Python):
import sys

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

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

x = A * 3
y = x + P

print(y//2)

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

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

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

a_piece = A * 3

total = a_piece + P

apple_pi = total / 2

print(int(apple_pi))

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

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

Solution (Python):


def solve():
    A, P = list(map(int, input().split()))
    sum_kakera  = A*3 + P

    ans = sum_kakera // 2

    print(ans)

if __name__ == "__main__":
    solve()

Solution (Python):
a, p = [int(c) for c in 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((3*A+P)//2)

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

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

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

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

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

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

Solution (Python):


import sys

debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]


    token = lines[0].split()
    a = int(token[0])
    p = int(token[1])

    return (a, p)


def solve(a, p):

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




def main():
    

    print("%s" % solve(*parse_input()))

if __name__ == '__main__':

    main()

Solution (Python):
"""
import sys
sys.setrecursionlimit(10**9)
N=int(input())
D=[]
for i in range(N):
  s,p=input().split()
  D.append((s, int(p), i+1))
D.sort(key=lambda d: (d[0], -d[1], d[2]))

for d in D:
  print(d[2])
"""
A,P=map(int, input().split())
print((A*3+P)//2)

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

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

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

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

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

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

Solution (Python):
from sys import stdin
A, P = [int(_) for _ in stdin.readline().rstrip().split()]
print((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((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):
apple, tip = map(int,input().split())

material = 3 * apple + tip
pie = material // 2

print(pie)

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

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

Solution (Python):
import math

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

P += A * 3

print(math.floor(P / 2))

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

pic =  (A*3)+P

print(pic //2)

Solution (Python):
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))

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

Solution (Python):
A,P=map(int,input().split())
P=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=map(int,input().split())
print((A*3+P)//2)

Solution (Python):
A,P = (int(x) for x in input().split())
print(int((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())
P += A * 3
print(int(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
print(int(P/2))

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

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

Solution (Python):
A,B = (int(i) for i in input().split()) 
C=3*A
D=int(0)
if (C+B)%2==1:
    D=(C+B-1)/2
else:
    D=(C+B)/2
print('%d'%D)

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

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


if __name__ == "__main__":
    main()

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

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

Solution (Python):
i = list(input().split(' '))

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

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


ap_chip += app*3


print(int(ap_chip/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):
import math
a, p = map(int, input().split())
piece = a*3
piece = piece + p
print(math.floor(piece/2))

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

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

Solution (Python):
import sys
INPUT = sys.stdin.readline

def SINGLE_INT(): return int(INPUT())
def MULTIPLE_INT_LIST(): return list(map(int, INPUT().split()))
def MULTIPLE_INT_MAP(): return map(int, INPUT().split())
def SINGLE_FLOAT(): return float(INPUT())
def MULTIPLE_FLOAT_LIST(): return list(map(float, INPUT().split()))
def MULTIPLE_FLOAT_MAP(): return map(float, INPUT().split())
def SINGLE_STRING(): return INPUT()
def MULTIPLE_STRING(): return INPUT().split()

A, B = MULTIPLE_INT_MAP()

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

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

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

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

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

Solution (Python):
import math
import numpy as np
 
A,P=map(int,input().split())
 
K = 3*A + P
ans = math.floor(K/2)
print(ans)

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

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

Solution (Python):
import math

inp = input()
nu = inp.rfind(' ')
A = inp[:nu:]
P = inp[nu+1::]
A, P = int(A), int(P)

piece = 3 * A + P

print(math.floor(piece / 2))

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

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

print(ans)

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

Solution (Python):


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

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

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

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

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

kakera = A * 3 + P

pie = kakera // 2

print(pie)

Solution (Python):
n =input().split()

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

print(num1)

Solution (Python):
import sys
A, P = (int(i) for i in input().split())
if int((A*3+P)) > 0:
    print(int((A*3+P)/2))
else:
    print(0)

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

Solution (Python):

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

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

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

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

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

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

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

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

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

k = A * 3

a = (P + k) / 2

print(int(a))

Solution (Python):
a, p = map(int,input().split())
ans = (a * 3 + 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())

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

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

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

c = 3 * a + p

result = int(c / 2)

print(result)

Solution (Python):


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

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

print(b)

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

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

ringo = A*3 + P
ringo = ringo // 2
print("{:.0f}".format(ringo))

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

Solution (Python):
data = input().split(" ")
apple = int(data[0])
piece=int(data[1])
piece+=apple*3;
print(int(piece/2))

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

def pie(a, p):
    piece = p + a * 3
    pies = piece // 2
    print(pies)

pie(a, p)

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

Solution (Python):






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





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

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

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

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):
A, P = map(int, input().split())
print(int((3 * A + P) / 2))

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

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 = [int(i) for i in input().split()]
print((A*3 + 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())
print((A * 3 + P) // 2)

Solution (Python):
import sys

A, P = input().split()

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

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return input()
from collections import Counter

def main():
    A, P = LI()
    X = P + A * 3
    ans = X // 2
    return ans

print(main())

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

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

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

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

Solution (Python):
import sys

inputs =  list(map(int, sys.stdin.readline().split()))

sum_break_apple = inputs[0]*3 + inputs[1]

print(int(sum_break_apple/2))

Solution (Python):


from sys import stdout
from bisect import bisect_left as binl
from copy import copy, deepcopy
from collections import defaultdict
import math


mod = 1


def intin():
    input_tuple = input().split()
    if len(input_tuple) <= 1:
        return int(input_tuple[0])
    return tuple(map(int, input_tuple))


def intina():
    return [int(i) for i in input().split()]


def intinl(count):
    return [intin() for _ in range(count)]


def modadd(x, y):
    global mod
    return (x + y) % mod


def modmlt(x, y):
    global mod
    return (x * y) % mod


def lcm(x, y):
    while y != 0:
        z = x % y
        x = y
        y = z
    return x


def combination(x, y):
    assert(x >= y)

    ret = math.factorial(x)
    ret = ret // (math.factorial(x - y) * math.factorial(y))

    return ret


def get_divisors(x):
    retlist = []
    for i in range(1, int(x**0.5) + 3):
        if x % i == 0:
            retlist.append(i)
            retlist.append(x // i)
    return retlist


def get_factors(x):
    retlist = []
    for i in range(2, int(x**0.5) + 3):
        while x % i == 0:
            retlist.append(i)
            x = x // i
    retlist.append(x)
    return retlist


def make_linklist(xylist):
    linklist = {}
    for a, b in xylist:
        linklist.setdefault(a, [])
        linklist.setdefault(b, [])
        linklist[a].append(b)
        linklist[b].append(a)
    return linklist


def calc_longest_distance(linklist, v=1):
    distance_list = {}
    distance_count = 0
    distance = 0
    vlist_previous = []
    vlist = [v]
    nodecount = len(linklist)

    while distance_count < nodecount:
        vlist_next = []
        for v in vlist:
            distance_list[v] = distance
            distance_count += 1
            vlist_next.extend(linklist[v])
        distance += 1
        vlist_to_del = vlist_previous
        vlist_previous = vlist
        vlist = list(set(vlist_next) - set(vlist_to_del))

    max_distance = -1
    max_v = None
    for v, distance in distance_list.items():
        if distance > max_distance:
            max_distance = distance
            max_v = v

    return (max_distance, max_v)


def calc_tree_diameter(linklist, v=1):
    _, u = calc_longest_distance(linklist, v)
    distance, _ = calc_longest_distance(linklist, u)
    return distance


class UnionFind:

    def __init__(self, n):
        self.parent = [i for i in range(n)]

    def root(self, i):
        if self.parent[i] == i:
            return i
        self.parent[i] = self.root(self.parent[i])
        return self.parent[i]

    def unite(self, i, j):
        rooti = self.root(i)
        rootj = self.root(j)
        if rooti == rootj:
            return
        if rooti < rootj:
            self.parent[rootj] = rooti
        else:
            self.parent[rooti] = rootj

    def same(self, i, j):
        return self.root(i) == self.root(j)





def main():
    a, p = intin()

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


if __name__ == '__main__':
    main()

Solution (Python):

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

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

Solution (Python):
input_data = [int(x) for x in input().split()]
A = input_data[0]
P = input_data[1]


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

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

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

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

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