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):
from collections import Counter
from collections import deque
from functools import reduce
from pprint import pprint

import bisect
import copy
import fractions
import math
import random
import sys
import time
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) 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 MI(): return map(int, sys.stdin.readline().split())
def II(): return int(sys.stdin.readline())
def IS(): return input()
def C(x): return Counter(x)
def GCD_LIST(numbers): return reduce(fractions.gcd, numbers)
def LCM_LIST(numbers): return reduce(LCM, numbers)
def LCM(m, n): return (m * n // fractions.gcd(m, n))
def unite(x, y):
    
    x = root(x)
    y = root(y)
    if x == y:
        return
    
    node[x] = y
def same(x,y): return bool(root(x) == root(y))
def root(x):
    if node[x] == x:  
        return x
    else:
        node[x] = root(node[x])  
        return node[x]
def dfs(v):
    
    visited[v] = True
    for v2 in range(n):
        if graph[v][v2] == False:  
            continue
        if visited[v2] == True:  
            continue
        dfs(v2)


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

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

Solution (Python):
from sys import stdin

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

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

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

Solution (Python):


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

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

Solution (Python):

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

kudaku = a*3 + p

print(int(kudaku/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
input = sys.stdin.readline

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

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

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

P = A * 3 + P

print(P//2)

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

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

print(applepie)

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

Solution (Python):
import fractions
import numpy as np
import os
import sys

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

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

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

sum_ = a*3+p 

print(sum_//2)

Solution (Python):
import sys
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def II(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
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 SI(): return input()
YN = lambda b: print('YES') if b else print('NO')
yn = lambda b: print('Yes') if b else print('No')

def main():
    A, P = LI()
    print((3*A + 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((a*3+p)//2)

Solution (Python):
import math
a, p = map(int, raw_input().split(" "))

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

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

Solution (Python):
a, p = [int(_) for _ 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((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):

"""
AtCoder A
"""
import math







def main():
    
    A, B = list(map(int,input().split()))
    print(math.floor((A*3+B)/2))
    
if __name__ == "__main__":
    main()

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

"""
Created on Sun May 26 20:54:59 2019

@author: Yamazaki Kenichi
"""

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

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

Solution (Python):
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque, OrderedDict
from copy import deepcopy
from fractions import gcd
from functools import lru_cache, reduce
from math import ceil, floor
from sys import setrecursionlimit

import heapq as hq
import itertools as its
import operator as op



inf = float('inf')
N = 0


def set_inputs():
    global N
    return


def main():
    setrecursionlimit(100000)
    set_inputs()
    
    a, p = get_li()
    print((a * 3 + p) // 2)
    return


def get_int():
    return int(input())


def get_float():
    return float(input())


def get_str():
    return input().strip()


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


def get_lf():
    return [float(f) for f in input().split()]


def get_lc():
    return list(input().strip())


def get_data(n, types, sep=None):
    if len(types) == 1:
        return [types[0](input().strip()) for _ in range(n)]
    return list(zip(*(
        [t(x) for t, x in zip(types, input().strip().split(sep=sep))]
        for _ in range(n)
    )))


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

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

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

kakera = 3 * A + P

print(kakera // 2)

Solution (Python):


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

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

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

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

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

Solution (Python):

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

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

Solution (Python):
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, input().split()))
def inpl_str(): return list(input().split())

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

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())
b = 3*a + p
print("{}".format(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 = kakera // 2
print(ans)

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

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

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

ans = math.floor((3 * a + p) / 2)

print(ans)

Solution (Python):

"""



"""
import sys


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


def main(args):
    A, P = map(int, input().split())
    ans = solve(A, P)
    print(ans)


if __name__ == '__main__':
    main(sys.argv[1:])

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

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

ans = 3 * a + p

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

Solution (Python):
from sys import stdin
input = stdin.readline

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

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

Solution (Python):


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

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

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

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

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

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


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

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


if __name__ == '__main__':
    main()

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

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

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

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

parts += apple * 3
ans = parts // 2

print(ans)

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

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

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

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

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

print(ans)

Solution (Python):
import numpy as np
words = lambda t : list(map(t, input().split()))
a,p = words(int)

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

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((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):
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):
AP = list(map(int,input().split()))
output = (AP[0]*3+AP[1])//2
print(output)

Solution (Python):
import math

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

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

Solution (Python):
import sys
if sys.version_info[0] == 2:
    input = raw_input
sys.setrecursionlimit(2 ** 31 -1)

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

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

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

Solution (Python):


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

Solution (Python):


def f(A, P):
    return (3*A + P)//2


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


if __name__ == '__main__':
    main()

Solution (Python):


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

def intinput(): return map(int,sys.stdin.readline().split())

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

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

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

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)


def read_int():
    return int(input())


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


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


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(A, P):
    return ((A*3)+P) // 2


def main():
    A, P = read_int_n()
    print(slv(A, P))


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

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

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

print((M+N*3)//2)

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

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

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

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

Solution (Python):




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

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

peace = 3 * A + P
pie = peace // 2

print(pie)

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

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

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

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

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

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

tmp = a*3 + p

print(tmp//2)

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
input = sys.stdin.readline
 










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

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

	


if __name__ == "__main__":
	main()

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

Solution (Python):

if __name__ == '__main__':
    a,p = list(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())
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, p = map(int, input().split())
print(int((a * 3 + p ) / 2))

Solution (Python):
import sys

sys.setrecursionlimit(10**7)

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

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

Solution (Python):
import sys
from collections import deque
from collections import defaultdict
import math
sys.setrecursionlimit(20000000)

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

Solution (Python):
def read():
    A, P = list(map(int, input().strip().split()))
    return A, P


def solve(A, P):
    kakera = A * 3 + P
    pie = kakera // 2
    return pie


if __name__ == '__main__':
    inputs = read()
    print("%d" % solve(*inputs))

Solution (Python):


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

    p += a * 3

    print(p // 2)



if __name__ == '__main__':
    submit()

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









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

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

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

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

piece=a*3+p
if piece%2==1:
    pie=int((piece-1)/2)
else:
    pie=int(piece/2)

print(pie)

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

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

print(ans)

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

main()

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

P += A * 3

pie = P // 2

print(pie)

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

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

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

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

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

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

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

Solution (Python):

 
import math
import numpy as np
import random
import copy
import statistics 
import bisect
import heapq
from collections import defaultdict 

import random 

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

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

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

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

Solution (Python):


import math

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

s = a*3+p

print(s//2)

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

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

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

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

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

Solution (Python):
import sys
import os


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

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

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

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

sys.setrecursionlimit(10 ** 7)

def li(): return map(int, stdin.readline().split())
def li_(): return map(lambda x: int(x) - 1, stdin.readline().split())
def lf(): return map(float, stdin.readline().split())
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())

a,p = li()
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())
ans = (A*3+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())

P += A * 3

pie = P // 2

print(pie)

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):
x, y = [int(i) for i in input().split()]
print(int((3*x+y)/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())
p+=a*3
print(p//2)

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



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

Solution (Python):
import math
 
n,m = list(map(int, input().split()))

print((n*3+m)//2)

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

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

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

Solution (Python):
a, p= map(int,open(0).read().split())

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

Solution (Python):
l = raw_input().split()
A = int(l[0])
P = int(l[1])

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

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

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

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

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

p += 3*a

ans = (int)(p / 2)

print(ans)

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


main()

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

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

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

piece=a*3+p
if piece%2==1:
    pie=int((piece-1)/2)
else:
    pie=int(piece/2)

print(pie)

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

kakera = P + A*3
applepie = kakera // 2

print(applepie)

Solution (Python):
a, b = (int(_) for _ in 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())

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

Solution (Python):


def readInts():
  return [int(s) for s in input().split(" ")]

def main():
  A, P = readInts()
  ans = (A * 3 + P) // 2
  print(ans)

if __name__ == "__main__":
  main()

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

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

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

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

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

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

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

Solution (Python):



N, M = map(int, input().rstrip().split(' '))

print((N * 3 + M) // 2)

Solution (Python):
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  

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

Solution (Python):
import bisect
from operator import itemgetter
import math
import functools
import itertools
import numpy as np
import sys
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

A,P = IL()

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

Solution (Python):
import sys
from fractions import gcd
import bisect

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()
s = lambda h: [list(map(int, stdin.readline().split())) for i in range(h)]



a, p = na()

keppen = 3 * a + p

print(keppen // 2)

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

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

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

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

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

Solution (Python):
import sys
import collections
ns = lambda: sys.stdin.readline().rstrip()
ni = lambda: int(ns())
nm = lambda: map(int, sys.stdin.readline().split())
nl = lambda: list(nm())
nsm = lambda: map(str, sys.stdin.readline().split())

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

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

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

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

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

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

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

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((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())
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,b=input().split()
a=int(a)
b=int(b)
x=3*a+b
print(x//2)

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

Solution (Python):

"""
Created on Sun May 26 20:58:25 2019

@author: USER
"""

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

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

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

Solution (Python):
import bisect
import heapq
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):
def gcd_core(a, b):
    if b == 0:
        return a
    else:
        return gcd_core(b, a % b)


def gcd(arr):
    g = gcd_core(arr[0], arr[1])
    for i in range(2, len(arr)):
        g = gcd_core(g, arr[i])
    return g

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

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

Solution (Python):
import math
import fractions
import copy

def j(q):
    if q==1: print("YES")
    elif q == 0:print("NO")
    exit(0)
rem = pow(10,9)+7
"""
def ct(x,y):
    if (x>y):print("+")
    elif (x<y): print("-")
    else: print("?")
"""

def ip():
    return int(input())
def printrow(a):
    for i in range(len(a)):
        print(a[i])
def combinations(n,r):
    if n<r:return 0
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def permutations(n,r):
    if n<r:return 0
    return math.factorial(n) // math.factorial(n - r)
def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)



m,n= (int(i) for i in input().split())       








print((m*3+n)//2)

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

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

Solution (Python):
from sys import exit

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
print(p//2)

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())
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):
import math
import fractions
import copy

def j(q):
    if q==1: print("YES")
    elif q == 0:print("NO")
    exit(0)
rem = pow(10,9)+7
"""
def ct(x,y):
    if (x>y):print("+")
    elif (x<y): print("-")
    else: print("?")
"""

def ip():
    return int(input())
def printrow(a):
    for i in range(len(a)):
        print(a[i])
def combinations(n,r):
    if n<r:return 0
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def permutations(n,r):
    if n<r:return 0
    return math.factorial(n) // math.factorial(n - r)
def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)



m,n= (int(i) for i in input().split())       








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

k = a * 3 + p

print(k//2)

Solution (Python):

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


if __name__ == '__main__':
    main()

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

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

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

if __name__ == '__main__':
    main()