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)

#[macro_use]
#[allow(dead_code)]
mod template {
    macro_rules! debug {
        ($($a:expr),*) => {{
            use ::std::io::Write;
            writeln!(&mut ::std::io::stderr(), concat!($(stringify!($a), " = {:?}, "),*), $($a),*).unwrap();
        }}
    }

    macro_rules! input {
        (source = $s:expr, $($r:tt)*) => {
            let mut scanner = ::template::BufScanner::new($s.as_bytes());
            input_inner!{scanner, $($r)*}
        };
        ($($r:tt)*) => {
            let stdin = ::std::io::stdin();
            let mut scanner = ::template::BufScanner::new(stdin.lock());
            input_inner!{scanner, $($r)*}
        };
    }

    macro_rules! input_inner {
        ($scanner:expr) => {};
        ($scanner:expr, ) => {};

        ($scanner:ident, $var:ident : $t:tt $($r:tt)*) => {
            let $var = read_value!($scanner, $t);
            input_inner!{$scanner $($r)*}
        };
    }

    macro_rules! read_value {
        ($scanner:ident, ( $($t:tt),* )) => {
            ( $(read_value!($scanner, $t)),* )
        };

        ($scanner:ident, [ $t:tt ; $len:expr ]) => {
            (0..$len).map(|_| read_value!($scanner, $t)).collect::<Vec<_>>()
        };

        ($scanner:ident, chars) => {
            read_value!($scanner, String).chars().collect::<Vec<char>>()
        };

        ($scanner:ident, usize1) => {
            read_value!($scanner, usize) - 1usize
        };

        ($scanner:ident, $t:ty) => {
            ($scanner).next::<$t>()
        };
    }

    pub struct BufScanner<R: ::std::io::BufRead> {
        br: R,
        buf: Vec<u8>,
        pos: usize,
    }

    impl<R: ::std::io::BufRead> BufScanner<R> {
        pub fn new(br: R) -> Self {
            BufScanner {
                br: br,
                buf: Vec::new(),
                pos: 0usize,
            }
        }
        fn fill_line(&mut self) {
            self.buf.clear();
            self.pos = 0;
            self.br
                .read_until(b'\n', &mut self.buf)
                .expect("Read a line");
            if let Some(&b'\n') = self.buf.last() {
                self.buf.pop();
                if let Some(&b'\r') = self.buf.last() {
                    self.buf.pop();
                }
            }
        }
        fn skip_space(&mut self) {
            loop {
                for i in self.pos..self.buf.len() {
                    if self.buf[i] != b' ' {
                        self.pos = i;
                        return;
                    }
                }
                self.fill_line();
            }
        }
        pub fn read_token(&mut self) -> &str {
            self.skip_space();
            let start = self.pos;
            while self.pos < self.buf.len() && self.buf[self.pos] != b' ' {
                self.pos += 1;
            }
            let ret = unsafe { ::std::str::from_utf8_unchecked(&self.buf[start..self.pos]) };
            self.pos += 1; // skip the last space (or len() + 1 which is fine)
            return ret;
        }
        pub fn next<T: ::std::str::FromStr>(&mut self) -> T {
            self.read_token().parse::<T>().ok().expect("Parse")
        }
    }
}

fn burger_size(level: u32) -> u64 {
    return if level == 0 {
        1
    } else {
        3 + 2 * burger_size(level - 1)
    };
}

fn count_p(level: u32) -> u64 {
    return if level == 0 {
        1
    } else {
        1 + 2 * count_p(level - 1)
    };
}

fn solve(level: u32, mut n: &mut u64) -> u64 {
    let size = burger_size(level);
    return if *n == 0 {
        0
    } else if *n >= size {
        *n -= size;
        count_p(level)
    } else {
        // level != 0
        *n -= 1; // bun
        let mut res = solve(level - 1, &mut n);
        if *n > 0 {
            res += 1;
            *n -= 1;
        }
        res += solve(level - 1, &mut n);
        if *n > 0 {
            *n -= 1; // bun
        }
        res
    };
}

fn main() {
    input! {
        level: u32,
        n: u64,
    }
    let mut n = n;
    let res = solve(level, &mut n);
    println!("{}", res);
}