human
Write me a Python program to find the number of bottles and towels needed for the tournament given the following:
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.
Using python3 can you solve the prior task?
assistant
#Here is Python program to find the number of bottles and towels needed for the tournament.

import 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()]
#    ...