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

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

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

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().strip().split(' '))
print((P+A*3)//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())
print((3 * A + P) // 2)

Solution (Python):

import sys


def solve(A: int, P: int):
    ret = (3 * A + P) // 2
    print(ret)
    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()))
print(((a*3) + 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())

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

print(res)

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

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

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

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

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

Solution (Python):
apple_num, apple_peace = map(int, input().split())

peace_sum = 3 * apple_num + apple_peace

print(peace_sum // 2)

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

a_particle = A * 3 + P

num_max = a_particle // 2
print num_max

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

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

Solution (Python):
import sys

readline = sys.stdin.readline

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

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

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

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

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

Solution (Python):

import os
import time
import re
import math


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

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

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

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

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

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

Solution (Python):


from sys import stdin

input = stdin.readline

A, P = list(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(int(p/2))

Solution (Python):
from collections import *
from functools import *
from itertools import *

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


if __name__ == "__main__":
    main()
    pass

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())
f=a*3+p
if f%2==1:
  f=f-1
print(int(f/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())

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

print(ans)

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

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

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

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

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

piece = 0
pie = 0

piece = A * 3 + P

print(int(piece / 2))

Solution (Python):
import sys
import re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from copy import copy
import numpy as np
from numpy.fft import fft, ifft
from fractions import gcd


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


def INT(): return int(input())


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


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


sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

a, p = MAP()

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

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

Solution (Python):

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

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

Solution (Python):
import numpy as np
from collections import defaultdict
from functools import reduce




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

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

class Interval():
    def __init__(self, li):
        self.li = li
        self.n = len(li)
        self.sum_li = [li[0]]
        for i in range(1, self.n):
            self.sum_li.append(self.sum_li[i-1] + li[i])

    def sum(self, a, b=None):
        if b is None:
            return self.sum(0, a)

        res = self.sum_li[min(self.n-1, b-1)]
        if a > 0:
            res -= self.sum_li[a-1]
        return res

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

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

print(applepie(A,P))

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

Solution (Python):



from sys import stdin






n = stdin.readline().split()
a = int(n[0])
b = int(n[1])



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

print(out)

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

Solution (Python):
import math
A, P = [int(s) for s in input().split(" ")]
print(math.floor((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())

b = a*3 + p

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

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

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

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

P = P + A * 3

print(int(P / 2))

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())
N=(3*A+P)
if N%2==1:
    N=N-1
    
print(int(N/2))

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

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

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

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

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

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

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

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

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

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

print("%d" % ((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()]
p += 3*a
pi = p//2
print(pi)

Solution (Python):

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

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

if __name__ == "__main__":
    main()

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

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

print(ans)

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

Solution (Python):

import sys


def solve(A: int, P: int):
    print(int((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):



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


if __name__ == '__main__':
    main()

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

if __name__=='__main__':
    main()

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

kakera = A * 3 + P

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

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

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

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

print(ans)

Solution (Python):

apple = input()
apple = apple.split(" ")
piece =  int(apple[0])*3 + int(apple[1])
pie = int(piece)/2
print(int(pie))

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 sys
input = sys.stdin.readline

num=[]
num=[int(i) for i in input().split()]

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

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

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

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

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

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

print(ans)

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

p += 3*a

ans = p //2

print(ans)

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

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

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

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

Solution (Python):
import sys


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

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

main()

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

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

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

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

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

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

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

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

p += a * 3

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

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

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

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

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

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

Solution (Python):


import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

A,P=MAP()

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

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

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

Solution (Python):

import copy
import random
import bisect 
import fractions 
import math
import sys

mod = 10**9+7
sys.setrecursionlimit(mod) 

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

s = a*3 + p

print(int(s/2))

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

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



print(int(pie))

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

Solution (Python):



import math
import re

def main(params):
    a,p = [int(i) for i in params[0].split()]
    t = (a * 3 + p) / 2
    print t


if __name__ == "__main__":
    cnt = 1 
    params = []
    for i in range(cnt):
        param = raw_input()
        params.append(param)
    main(params)

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

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

Solution (Python):
from sys import stdin
A,P=[int(x) for x in stdin.readline().rstrip().split()]
ans=(A*3+P)/2
print(int(ans))

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):
num = input().split()

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

print(sum_apple//2)

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

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

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

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

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

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

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

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

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

Solution (Python):
from sys import stdin
    
def main():
    a,p = [int(x) for x in stdin.readline().rstrip().split()]

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

if __name__=='__main__':
    main()

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

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

Solution (Python):
i = input().split(" ")

a = int(i[0])
p = int(i[1])

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

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

Solution (Python):

import sys
from collections.abc import Iterable
from math import *
from itertools import *
from collections import *
from functools import *
from operator import *
try:
    from math import gcd
except Exception:
    from fractions import gcd


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


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))  
    result = solve(A, P)
    if isinstance(result, Iterable) and not isinstance(result, str):
        result = '\n'.join([str(v) for v in result])
    print(result)

if __name__ == '__main__':
    main()

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

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

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

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=input().split()
a=int(a)
p=int(p)
p=p+a*3
ans=int(p/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())
s = a*3 + p
print(s // 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())
b = a*3+p
c = b//2
print(c)

Solution (Python):

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

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

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

if __name__ == '__main__':
    solve()

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

ans = (A*3 + P)/2

print(int(ans))

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

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

Solution (Python):
import sys
from collections import deque
import copy
import math
def get_read_func(fileobject):
    if fileobject == None :
        return raw_input
    else:
        return fileobject.readline



def main():
    if len(sys.argv) > 1:
        f = open(sys.argv[1])
    else:
        f = None
    read_func = get_read_func(f);
    input_raw = read_func().strip().split()
    [A, P] = [int(input_raw[0]), int(input_raw[1])]
    print ((A*3) + P)/2
if __name__ == '__main__':
    main()

Solution (Python):

















import math
import copy
from collections import defaultdict
from collections import Counter
from collections import deque

from itertools import product

from itertools import permutations

from itertools import combinations
from bisect import bisect_left, bisect_right


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]

def i_inpl(): return int(input())
def s_inpl(): return map(int,input().split())
def l_inpl(): return list(map(int, input().split()))
INF = float("inf")





A, P = l_inpl()

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

Solution (Python):


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

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

Solution (Python):
import sys,heapq
from collections import deque,defaultdict
printn = lambda x: sys.stdout.write(x)
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
DBG = True 
def ddprint(x):
  if DBG:
    print(x)

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

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

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


if __name__ == '__main__':
    main()

Solution (Python):
import math

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

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

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

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

p = P + A*3

print(int(p/2))

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

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

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

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

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

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

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

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

print((((num1*3)+num2)//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, piece = map(int, input().split())
print(str((apple*3 + piece) // 2))

Solution (Python):


inputs = input().split(' ')
A = int(inputs[0])
P = int(inputs[1])

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

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

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

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

Solution (Python):
import numpy as np






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

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

print(max_pie)

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 numpy as np
A, P = [int(i) for i in input().split()]

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

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

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

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

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

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

Solution (Python):



def solv(a, p):
    return (a*3+p) // 2


if __name__ == '__main__':

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

    ans = solv(a, p)

    print(ans)

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

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

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

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

Solution (Python):
A, P = [int(x) for x in 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())

aaa = a*3+p

print(aaa//2)

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

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

N = A * 3 + P

print(int(N/2))

Solution (Python):


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

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

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

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

print(rtn)

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().rstrip().split())
n = A*3 + P
print(n//2)

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

parts = A * 3 + P

print(parts // 2)

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

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

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

print(ans)

Solution (Python):
import sys
range = xrange
input = raw_input

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

p += 3*a

print p//2

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

Solution (Python):

import sys


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

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 = 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())
a = a * 3
x = a + p
print(x//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 = list(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())
P2 = A * 3
T = P + P2
print(int(T / 2))

Solution (Python):
ap = list(map(int, input().split()))
a = ap[0]
p = ap[1]
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(int((a*3+p)//2))

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

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

Solution (Python):


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


if __name__ == '__main__':
    main()

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

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

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

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