human
A tennis tournament with n participants is running. The participants are playing by an olympic system, so the winners move on and the losers drop out.

The tournament takes place in the following way (below, m is the number of the participants of the current round):

  * let k be the maximal power of the number 2 such that k ≤ m, 
  * k participants compete in the current round and a half of them passes to the next round, the other m - k participants pass to the next round directly, 
  * when only one participant remains, the tournament finishes. 


Each match requires b bottles of water for each participant and one bottle for the judge. Besides p towels are given to each participant for the whole tournament.

Find the number of bottles and towels needed for the tournament.

Note that it's a tennis tournament so in each match two participants compete (one of them will win and the other will lose).

Input

The only line contains three integers n, b, p (1 ≤ n, b, p ≤ 500) — the number of participants and the parameters described in the problem statement.

Output

Print two integers x and y — the number of bottles and towels need for the tournament.

Examples

Input

5 2 3

Output

20 15

Input

8 2 4

Output

35 32

Note

In the first example will be three rounds:

  1. in the first round will be two matches and for each match 5 bottles of water are needed (two for each of the participants and one for the judge), 
  2. in the second round will be only one match, so we need another 5 bottles of water, 
  3. in the third round will also be only one match, so we need another 5 bottles of water. 


So in total we need 20 bottles of water.

In the second example no participant will move on to some round directly.
impor
assistant
#Here is Python code to find the number of bottles and towels needed for the tournament.
t queue
import math
import io

# n = int(input())
#
# class Sphere:
#     def __init__(self,x,y,r):
#         self.x = x
#         self.y = y
#         self.r = r
#         self.left =x-r
#         self.right = 300 - x+r
#
#     def has_route(self, shere):
#         return math.sqrt((self.x - shere.x)**2+(self.y-shere.y)**2) <=self.r+shere.r
#
#     def __str__(self):
#         return str(self.x)+'_'+str(self.y)+'_'+str(self.r)
#
# to_ = []
# sher = []
# sheres = {}
# sheres1 ={}
# def bfs(start):
#     q = queue.Queue()
#     q.put(start)
#     used ={}
#     d ={}
#     p ={}
#     for sher1 in sheres:
#         used[sher1]=False
#         d[sher1]=0
#         p[sher1]=0
#     used[start]=True
#     while not q.empty():
#         v = q.get()
#         for sh in sheres[v]:
#             if not used[sh]:
#                 used[sh]=True
#                 q.put(sh)
#                 d[sh]=d[v]+1
#                 p[sh]=v
#     return [used,d,p]
#
#
# for i in range(n):
#     [x,y,r] = [int(x) for x in input().split(' ')]
#     sher.append(Shere(x,y,r))
#     to_.append(sher[-1])
#     sheres1[str(sher[-1])]=sher[-1]
#
# to_.sort(key=lambda x: x.left)
#
#
#
#
# for i in range(len(sher)):
#     for j in range(len(sher)):
#         if i != j:
#             if sher[i].has_route(sher[j]):
#                 if str(sher[i]) in  sheres:
#                     sheres[str(sher[i])].append(str(sher[j]))
#                 else:
#                     sheres[str(sher[i])] = [str(sher[j])]
#             else:
#                 if str(sher[i]) not in sheres:
#                     sheres[str(sher[i])] = []
#
# [used,d,p] = bfs(str(sher[0]))
#
# print(d)
# print(p)
# print(sheres)
# print(to_)



#
# def relax(to, p):
#     v = to
#     res = []
#     while (v != -1):
#         res.append(v)
#         v = p[v]
#     return res
#
#
# [b, e, p, n, m] = [int(x) for x in input().split()]
# g = []
# for i in range(n+1):
#     g.append([])
# print(g)
# for i in range(m):
#     [to, v] = [int(x) for x in input().split()]
#    ...