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 Rust (1.15.1) (judge verdict: Accepted)

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}

fn read_vec2<T: std::str::FromStr>(n: usize) -> Vec<Vec<T>> {
    (0..n).map(|_| read_vec()).collect()
}

fn read_col<T: std::str::FromStr>(n: usize) -> Vec<T> {
    (0..n).map(|_| read()).collect()
}

fn eat(l: usize, x: u64, height: &Vec<u64>, patty: &Vec<u64>) -> u64 {
    if x == 0 {
        0
    } else if l == 0 {
        1
    } else if x == 1 {
        0
    } else if x < 1 + height[l - 1] {
        eat(l - 1, x - 1, height, patty)
    } else if x == 1 + height[l - 1] {
        patty[l - 1]
    } else if x == 2 + height[l - 1] {
        1 + patty[l - 1]
    } else if x < 2 + 2 * height[l - 1] {
        1 + patty[l - 1] + eat(l - 1, x - 2 - height[l - 1], height, patty)
    } else {
        patty[l]
    }
}

fn main() {
    let nx: Vec<u64> = read_vec();

    let mut height: Vec<u64> = vec![1; 51];
    let mut patty: Vec<u64> = vec![1; 51];
    for i in 1..51 {
        height[i] = 2 * height[i - 1] + 3;
        patty[i] = 2 * patty[i - 1] + 1;
    }

    println!("{}", eat(nx[0] as usize, nx[1], &height, &patty));
}