#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <math.h>
     
    #define BIG 2000000007
     
    #define MOD 1000000007
    typedef unsigned long long ull;
    typedef   signed long long sll;
     
    #define N_MAX 200000
    #define M_MAX 100
     
    typedef struct {
    	int a;
    	int b;
    } hw;
     
    typedef struct {
    	sll a;
    	sll b;
    } hwll;
     
     
    const hw vector8[8] = {
    	{-1, -1},
    	{-1,  0},
    	{-1, +1},
    	{ 0, -1},
    	{ 0, +1},
    	{+1, -1},
    	{+1,  0},
    	{+1, +1}
    };
     
    ull n, m;
    ull h, w;
    ull k;
    ull va, vb, vc, vd, ve, vf;
    // ull a[N_MAX];
    // sll a[N_MAX];
    // ull b[M_MAX];
    // ull dp[N_MAX][M_MAX + 1];
    char s[N_MAX + 1];
    // char t[N_MAX + 1];
    // char s[N_MAX][M_MAX + 1];
    // hw arr[N_MAX];
    // hwll arr[N_MAX];
    // hw brr[M_MAX];
    // ull digitdp[102][   2][    2];
    //          pos  less  carry
     
    void swap_adj(ull *a, ull *b){
    	ull tmp = *b;
    	*b = *a;
    	*a = tmp;
    	return;
    }
     
    ull divide(ull a, ull b){
    	ull x = MOD - 2;
    	ull ans = 1;
    	while (x) {
    		if (x & 1) ans = (ans * b) % MOD;
    		b = (b * b) % MOD;
    		x /= 2;
    	}
    	return (a * ans) % MOD;
    }
     
    int digits(ull x){
    	int i = 1;
    	while (x >= 10) {
    		x /= 10;
    		i++;
    	}
    	return i;
    }
     
    int min(ull x, ull y){
    	return (x < y) ? x : y;
    }
     
    ull gcd(ull x, ull y){
    	if (x < y) {
    		return gcd(y, x);
    	} else if (y == 0) {
    		return x;
    	} else {
    		return gcd(y, x % y);
    	}
    }
     
    ull bitpow(ull a, ull x){
    	ull result = 1;
    	while (x) {
    		if (x & 1) {
    			result *= a;
    			result %= MOD;
    		}
    		x /= 2;
    		a = (a * a) % MOD;
    	}
    	return result;
    }
     
    // int nextroute(int arr[]){
    // 	int i = n - 1;
    // 	int j, x;
    // 	while (arr[i - 1] > arr[i]) i--;
     
    // 	x = n;
    // 	for (j = i; j < n; j++) {
    // 		if (arr[j] < arr[i - 1]) continue;
    // 		if (x == n || arr[x] > arr[j]) x = j;
    // 	}
    // 	arr[i - 1] ^= arr[x];
    // 	arr[x] ^= arr[i - 1];
    // 	arr[i - 1] ^= arr[x];
     
    // 	qsort(&arr[i], n - i, sizeof(int), comp);
    // 	return 0;
    // }
     
    int nibutan_target(ull target){
    	ull maxdist = (target * (target + 1) / 2); // 時刻targetまでに到着できる距離は[-maxdist, maxdist]
    	return (n <= maxdist);
    }
     
    int targetdig(ull x, int index /* 1-indexed */){
    	// static...?
    	int posmax = digits(x);
    	if (posmax < index) return -1;
    	while (posmax > index) {
    		posmax--;
    		x /= 10;
    	}
    	return x % 10;
    }
     
    int intcomp(const void *left, const void *right){
    	if ((*(int*)left) < (*(int*)right)) {
    		return -1;
    	} else if ((*(int*)left) > (*(int*)right)) {
    		return +1;
    	} else {
    		return 0;
    	}
    }
     
    int ullcomp(const void *left, const void *right){
    	if ((*(ull*)left) < (*(ull*)right)) {
    		return -1;
    	} else if ((*(ull*)left) > (*(ull*)right)) {
    		return +1;
    	} else {
    		return 0;
    	}
    }
     
    int sllcomp(const void *left, const void *right){
    	if ((*(sll*)left) < (*(sll*)right)) {
    		return -1;
    	} else if ((*(sll*)left) > (*(sll*)right)) {
    		return +1;
    	} else {
    		return 0;
    	}
    }
     
    int hwAcomp(const void *left, const void *right){
    	return intcomp(&(((hw*)left)->a), &(((hw*)right)->a));
    }
     
    int hwBcomp(const void *left, const void *right){
    	return intcomp(&(((hw*)left)->b), &(((hw*)right)->b));
    }
     
    int hwABcomp(const void *left, const void *right){
    	int x = hwAcomp(left, right);
    	if (x) return x;
    	return hwBcomp(left, right);
    }
     
    int hwllAcomp(const void *left, const void *right){
    	return sllcomp(&(((hw*)left)->a), &(((hw*)right)->a));
    }
     
    int hwllBcomp(const void *left, const void *right){
    	return sllcomp(&(((hw*)left)->b), &(((hw*)right)->b));
    }
     
    int hwllABcomp(const void *left, const void *right){
    	int x = hwllAcomp(left, right);
    	if (x) return x;
    	return hwllBcomp(left, right);
    }
     
    int ispalin(int x){
    	return (x == 0) || ((x & -x) == x);
    }
     
    int bitlet(char c){
    	return (1 << (c - 'a'));
    }
     
    ull solve(){
    	int i, j, ki;
     
    	// ull x = (va > vb ? va - vb : vb - va);
    	// ull y = (vc > vb ? vc - vb : vb - vc);
     
    	// if (va % 2 == 1) {
    	// 	puts("0");
    	// } else if (x == 0 && y == 0) {
    	// 	puts("-1");
    	// } else {
    	// 	int ans = 0;
    	// 	while (x % 2 == 0 && y % 2 == 0) {
    	// 		ans++;
    	// 		x /= 2;
    	// 		y /= 2;
    	// 	}
    	// 	printf("%d\n", ans);
    	// }
     
    	int len = strlen(s);
     
    	int first = 0;
    	int last = len - 1;
    	int result = 0;
     
    	int palin = 0;
    	for (i = 0; i < len; i++) palin ^= bitlet(s[i]);
     
    	while (first <= last) {
    		int maylen = 0;
    		int fpartlin = 0;
    		int lpartlin = 0;
    		for (;;) {
    			if (ispalin(palin ^ fpartlin)) {
    				last = first + maylen - 1;
    				result++;
    				palin = fpartlin;
    				break;
    			}
    			if (ispalin(palin ^ lpartlin)) {
    				first = last - maylen + 1;
    				result++;
    				palin = lpartlin;
    				break;
    			}
    			fpartlin ^= bitlet(s[first + maylen]);
    			lpartlin ^= bitlet(s[ last - maylen]); 
    			maylen++;
     
    		}
    		printf("%d ~ %d\n", first, last);
    	}
     
    	printf("%d\n", result);
     
    	return 0;
    }
     
    int main(void){
    	int i, j;
    	int x, y;
    	int z = 1;
     
    	// scanf("%llu", &n);
    	scanf("%d%d", &x, &y);
     
    	// solve();
    	// printf("%d\n", (j * 2 - i));
    	for (i = 0; i < x; i++) {
    		if (z * 2 < z + y)
    			z *= 2;
    		else
    			z += y;
    	}
    	printf("%d\n", z);
     
    	return 0;
    }

Measured memory_bytes: 128