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.

import java.io.*;
import java.util.*;


//public class Main{		// codechef
//public class Solution{	// codeforces	hackerrank

public class Solution {

	static FastScanner in;
	static PrintWriter out;

	static ArrayList<String> colorList = new ArrayList<>();
	static HashMap<Integer, ArrayList<String>> colorMap = new HashMap<>();
	
	
	// write code
	static void solve() {
		int n=in.nextInt(),b=in.nextInt() ,p=in.nextInt();
		int bCount =0, tCount = p*n;
		while(1!=n){
			int k = (int) (Math.log10(n)/Math.log10(2)) ;
			int k2= (int) Math.pow(k, 2);
			int m = n- 2*k ;
			n= (k) + m;
			bCount += (k);
		}
		out.println(bCount*(2*b + 1));
		out.println(tCount);
	}


	// part of pre-defined template
	public static void run() {
		in = new FastScanner();
		out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		solve();
		out.close();
	}

	public static void main(String[] args) {
		run();
	}

	private static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner(String s) {
			try {
				br = new BufferedReader(new FileReader(s));
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

		public FastScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String nextToken() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int[] getArrayInt(int n) {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextInt();
			}
			return arr;
		}

		long[] getArrayLong(int n) {
			long[] arr = new long[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextLong();
			}
			return arr;
		}

		int nextInt() {
			return Integer.parseInt(nextToken());
		}

		long nextLong() {
			return Long.parseLong(nextToken());
		}

		double nextDouble() {
			return Double.parseDouble(nextToken());
		}
	}

}
