Problem:
Score : 400 points

Problem Statement

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.

Sample Input 1

2 7

Sample Output 1

4

There are 4 patties in the bottom-most 7 layers of a level-2 burger (BBPPPBPBPPPBB).

Sample Input 2

1 1

Sample Output 2

0

The bottom-most layer of a level-1 burger is a bun.

Sample Input 3

50 4321098765432109

Sample Output 3

2160549382716056

A level-50 burger is rather thick, to the extent that the number of its layers does not fit into a 32-bit integer.

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using static MyIO;


public class D
{
	public static void Main()
	{
		int N = GetInt();
		long X = GetLong();

		long[] numP = new long[N+1];
		long[] numTotal = new long[N+1];
		numP[0] = 1L;
		numTotal[0] = 1L;
		for(int i = 1; i <= N; i++)
		{
			numP[i] = 1L + 2L * numP[i-1];
			numTotal[i] = 3L + 2L * numTotal[i-1];
		}

		Solver solver = new Solver(numP, numTotal);
		Console.WriteLine(solver.eat(N, X));		
	}
}


public class Solver
{
	private long[] m_numP;
	private long[] m_numTotal;

	public Solver(long[] numP, long[] numTotal)
	{
		m_numP = numP;
		m_numTotal = numTotal;
	}

	public long eat(int level, long length)
	{
		if(length == 1L)
		{
			return 0L;
		}
		else if(length < 1L + m_numTotal[level - 1])
		{
			return eat(level - 1, length - 1L);
		}
		else if(length == 1L + m_numTotal[level - 1])
		{
			return m_numP[level - 1L];
		}
		else if(length == 2L + m_numTotal[level - 1])
		{
			return m_numP[level - 1] + 1L;
		}
		else if(length < 3L + 2 * m_numTotal[level - 1])
		{
			return m_numP[level - 1] + 1L + eat(level - 1, length - 2L - m_numTotal[level - 1]);
		}
		else
		{
			return m_numP[level];
		}
	}
}


public static class MyIO
{
	private static string[] args = null;
	private static int num = -1;
	private static int used = -1;

	private static string getArg()
	{
		if(used == num)
		{
			args = Console.ReadLine().Split(' ');
			num = args.Length;
			used = 0;
		}
		return args[used++];
	}

	public static int GetInt(){ return int.Parse(getArg()); }
	public static long GetLong(){ return long.Parse(getArg()); }
	public static double GetDouble(){ return double.Parse(getArg()); }
	public static string GetString(){ return getArg(); }
}