-----Problem Statement-----
Harry Potter has one biscuit and zero rupee in his pocket. He will perform the following operations exactly $K$ times in total, in the order he likes:
- Hit his pocket, which magically increases the number of biscuits by one.
- Exchange $A$ biscuits to $1$ rupee.
- Exchange $1$ rupee to $B$ biscuits.
Find the maximum possible number of biscuits in Harry's pocket after $K$ operations.

-----Input-----
Input is given in the following format:
K A B

-----Output-----
Print the maximum possible number of biscuits in Harry's pocket after $K$operations.

-----Constraints-----
- $1 \leq K, A, B \leq 10^9$
- $K$, $A$ and  are integers.

-----Sample Input-----
4 2 6

-----Sample Output-----
7

-----EXPLANATION-----
The number of biscuits in Harry's pocket after $K$ operations is maximized as follows:
- Hit his pocket. Now he has $2$ biscuits and $0$ rupee.
- Exchange $2$ biscuits to $1$ rupee in his pocket .Now he has $0$ biscuits and $1$ rupee.
- Hit his pocket. Now he has $1$ biscuits and $1$ rupee.
- Exchange $1$ rupee to $6$ biscuits. his pocket. Now he has $7$ biscuits and $0$ rupee.

Source: codechef | Difficulty: UNKNOWN_DIFFICULTY


Solutions:
(K, A, B) = map(int, input().split())
if A + 2 > B:
	print(K + 1)
	return
start = A - 1
K -= start
ans = K // 2 * (B - A) + K % 2 + start + 1
print(ans)


import sys
import math
import collections
from sys import stdin, stdout, setrecursionlimit
import bisect as bs
setrecursionlimit(2 ** 20)
M = 10 ** 9 + 7
T = 1
for _ in range(T):
	(n, a, b) = list(map(int, stdin.readline().split()))
	if a > n - 1:
		print(n + 1)
		continue
	if b - a - 2 > 0:
		ans = a
		op = n - (a - 1)
		ans += op // 2 * (b - a)
		ans += op % 2
		print(ans)
		continue
	print(n + 1)


import sys
import math, bisect
sys.setrecursionlimit(10 ** 5)
from collections import defaultdict
from itertools import groupby, accumulate
from heapq import heapify, heappop, heappush
from collections import deque, Counter, OrderedDict

def I():
	return int(sys.stdin.readline())

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

def Neo():
	return list(map(int, sys.stdin.readline().split()))
(k, a, b) = neo()
if k + 1 < a:
	print(k + 1)
	return
k -= a - 1
q = a + k
if b > a:
	t = k // 2
	a += (b - a) * t
	if k - t * 2 > 0:
		a += 1
	print(max(a, q))
	return
print(q)


import sys
import math
from collections import defaultdict, Counter
(k, a, b) = list(map(int, input().split()))
if b <= a + 2 or k <= a:
	ans = 1 + k
else:
	k -= a - 1
	ans = a + k // 2 * (b - a)
	if k & 1:
		ans += 1
print(ans)


(k, a, b) = map(int, input().split())
if b - a <= 2:
	print(k + 1)
else:
	count = a
	k = k - (a - 1)
	count += (b - a) * (k >> 1)
	count += k & 1
	print(count)


import sys
import math
import random
input = sys.stdin.readline

def inp():
	return int(input())

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return list(map(int, input().split()))
(k, a, b) = invr()
if k < a - 1:
	print(1 + k)
	return
now = a
k -= a - 1
if b - a >= 3:
	now = a + k // 2 * (b - a) + k % 2
else:
	now = a + k
print(now)


import sys
import math as mt
import bisect
input = sys.stdin.readline
t = 1
for _ in range(t):
	(k, a, b) = list(map(int, input().split()))
	ans = k + 1
	ans1 = 1
	op1 = min(a - ans1, k)
	k -= op1
	if k > 0:
		ex = k // 2
		ans1 = a + ex * (b - a)
		if k % 2 != 0:
			ans1 += 1
	print(max(ans, ans1))