In some other world, today is Christmas.

Mr. Takaha decides to make a multi-dimensional burger in his party. A level-L burger (L is an integer greater than or equal to 0) is the following thing:

* A level-0 burger is a patty.
* A level-L burger (L \geq 1) is a bun, a level-(L-1) burger, a patty, another level-(L-1) burger and another bun, stacked vertically in this order from the bottom.



For example, a level-1 burger and a level-2 burger look like `BPPPB` and `BBPPPBPBPPPBB` (rotated 90 degrees), where `B` and `P` stands for a bun and a patty.

The burger Mr. Takaha will make is a level-N burger. Lunlun the Dachshund will eat X layers from the bottom of this burger (a layer is a patty or a bun). How many patties will she eat?

Constraints

* 1 \leq N \leq 50
* 1 \leq X \leq ( the total number of layers in a level-N burger )
* N and X are integers.

Input

Input is given from Standard Input in the following format:


N X


Output

Print the number of patties in the bottom-most X layers from the bottom of a level-N burger.

Examples

Input

2 7


Output

4


Input

1 1


Output

0


Input

50 4321098765432109


Output

2160549382716056
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

	public static void main(String[] args) throws IOException {
		Main mainObj = new Main();
		mainObj.solve();
	}
	
	long[] hamburgerHeightArr;
	long[] pattyHeightArr;

	public void solve() throws IOException {
		FastScanner fs = new FastScanner();
		int n = fs.nextInt();
		long x = fs.nextLong();
		
		hamburgerHeightArr = new long[n+1];
		pattyHeightArr = new long[n+1];
		hamburgerHeightArr[0] = 1;
		pattyHeightArr[0] = 1;
		for(int i = 1; i < n+1; i++){
			hamburgerHeightArr[i] = 3 + 2*hamburgerHeightArr[i-1];
			pattyHeightArr[i] = 1+ 2* pattyHeightArr[i-1];
		}
		
		System.out.println(calcPattyNum(n,x));
	}
	
	
	long calcPattyNum(int hamburgerHeight, long x){
		
		if(hamburgerHeight == 0){
			if(x == 0){
				return 0;
			}else{
				return 1;
			}
		}
		
		if(x == 1){
			return 0;
		}
		
		if(x <= hamburgerHeightArr[hamburgerHeight-1]+1){
			return calcPattyNum(hamburgerHeight-1, x-1);
		}
		
//		if(x == hamburgerHeightArr[hamburgerHeight-1]+1){
//			return pattyHeightArr[hamburgerHeight-1];
//		}
		
		if(x == hamburgerHeightArr[hamburgerHeight-1]+2){
			return pattyHeightArr[hamburgerHeight-1]+1;
		}
		
		if(x <= hamburgerHeightArr[hamburgerHeight] - 1){
			return pattyHeightArr[hamburgerHeight-1] + 1 + calcPattyNum(hamburgerHeight-1 , x-2-hamburgerHeightArr[hamburgerHeight-1]); 
		}
		
		return pattyHeightArr[hamburgerHeight];
	}
	

	public class FastScanner {

		BufferedReader reader;
		private StringTokenizer st;

		public FastScanner() {
			st = null;
			reader = new BufferedReader(new InputStreamReader(System.in));
		}

		public String next() throws IOException {
			if (st == null || !st.hasMoreElements()) {
				st = new StringTokenizer(reader.readLine());
			}
			return st.nextToken();
		}

		public String nextLine() throws IOException {
			st = null;
			String readLine = null;
			readLine = reader.readLine();
			return readLine;
		}

		public int nextInt() throws NumberFormatException, IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws NumberFormatException, IOException {
			return Long.parseLong(next());
		}

		public int[] nextIntArr(int n) throws NumberFormatException, IOException {
			int[] retArr = new int[n];
			for (int i = 0; i < n; i++) {
				retArr[i] = nextInt();
			}
			return retArr;
		}

		public long[] nextLongArr(int n) throws NumberFormatException, IOException {
			long[] retArr = new long[n];
			for (int i = 0; i < n; i++) {
				retArr[i] = nextLong();
			}
			return retArr;
		}

		public void close() throws IOException {
			reader.close();
		}
	}

}
