-----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.

Difficulty: interview

Starter code:

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
# sys.stdin = open('input.txt', 'r') 
# sys.stdout = open('output.txt', 'w')
 
import math
import collections
from sys import stdin,stdout,setrecursionlimit
import bisect as bs
setrecursionlimit(2**20)
M = 10**9+7

# T = int(stdin.readline())
T = 1

for _ in range(T):
    # n = int(stdin.readline())
    n,a,b = list(map(int,stdin.readline().split()))
    # h = list(map(int,stdin.readline().split()))
    # q = int(stdin.readline())
    # a = list(map(int,stdin.readline().split()))
    # 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

# input=sys.stdin.readline
# def print(x):
#     sys.stdout.write(str(x)+"\n")

# sys.stdout=open("CP3/output.txt",'w')
# sys.stdin=open("CP3/input.txt",'r')

# mod=pow(10,9)+7
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
#from queue import *
import random
#sys.setrecursionlimit(int(1e6))
input = sys.stdin.readline
 
############ ---- USER DEFINED INPUT FUNCTIONS ---- ############
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())))
################################################################
############ ---- THE ACTUAL CODE STARTS BELOW ---- ############

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=int(input())
t=1  
  
            
   
for _ in range(t):
    #n=int(input())
    #n,k=map(int,input().split())
    k,a,b=list(map(int,input().split()))
    #n,h=(map(int,input().split()))
    #l1=list(map(int,input().split()))
    #l2=list(map(int,input().split()))
    #mat=[[0 for j in range(c+1)] for i in range(r+1)]
    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))