Guess Your Way Out!

Amr bought a new video game "Guess Your Way Out!". The goal of the game is to find an exit from the maze that looks like a perfect binary tree of height h. The player is initially standing at the root of the tree and the exit from the tree is located at some leaf node.

Let's index all the leaf nodes from the left to the right from 1 to 2h. The exit is located at some node n where 1 ≤ n ≤ 2h, the player doesn't know where the exit is so he has to guess his way out!

Amr follows simple algorithm to choose the path. Let's consider infinite command string "LRLRLRLRL..." (consisting of alternating characters 'L' and 'R'). Amr sequentially executes the characters of the string using following rules:

• Character 'L' means "go to the left child of the current node";
• Character 'R' means "go to the right child of the current node";
• If the destination node is already visited, Amr skips current command, otherwise he moves to the destination node;
• If Amr skipped two consecutive commands, he goes back to the parent of the current node before executing next command;
• If he reached a leaf node that is not the exit, he returns to the parent of the current node;
• If he reaches an exit, the game is finished.

Now Amr wonders, if he follows this algorithm, how many nodes he is going to visit before reaching the exit?

Input

Input consists of two integers h, n (1 ≤ h ≤ 50, 1 ≤ n ≤ 2h).

Output

Output a single integer representing the number of nodes (excluding the exit node) Amr is going to visit before reaching the exit by following this algorithm.

Sample test(s)

input

1 2

output

2

input

2 3

output

5

input

3 6

output

10

input

10 1024

output

2046

Note

A perfect binary tree of height h is a binary tree consisting of h + 1 levels. Level 0 consists of a single node called root, level h consists of 2h nodes called leaves. Each node that is not a leaf has exactly two children, left and right one.

Following picture illustrates the sample test number 3. Nodes are labeled according to the order of visit.

 ##################################editorial######################################  first we need to calculate the node no in which exit is .. now we  start from exit node .. if this node is right to its parent and its parent is right to his parent than  this is sure that before accessing this node from its parent left sub tree of its parent must be covered ..(since R,R move is note possible ).

 example ---  let exit node be node  5 in above case .. 5 is right  of its parent  3 and 3 is also 

of right of its parent  2  .. before accessing   node 5 node 4 must be covered (left tree of parent of 5)..

 same thing is apply for L-L MOVE ALSO 

orrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr

in simpler way  if you r accessing odd  position node(1 based indexing ) from odd position node as parrent than this is a R R move so 1st need to cover left sub tree.. similarly if u are acessing  even position  node node from even position parent than 1st need to cover right sub tree else if odd-even or even - odd  than  just increase count for parent node ......

##################################code###################################

#include<iostream>

using namespace std;

#include<bits/stdc++.h>

int main()

 {

  long long int h,n;

  cin>>h>>n;

  n=pow(2,h)+n-1;// finding position ofexit node .. consider root node as index =1;

   //cout<<n<<endl;

 long long  int ans=0;

    for(int i=h;i>=1;i--)// total no of hight need to travel

     {

      if(n%2==1 ) //means node is odd position 

      {

      if((n/2)%2==1) //means parent is also odd position 

      {

      ans+=pow(2,h-i+1);// need to cover left sub tree

      }

      else

      {

      ans+=1;// means L-R MOVE  so just include parrent 

      }

      n/=2;//   shift exit node to upper level

      }

      else 

      {

      if((n/2)%2==0)//  L-L move 

      {

      ans+=pow(2,h-i+1);// cover right subtree

      }

      else

      {

      ans+=1;

      }

      n/=2;

      }

     

     }

      cout<<ans<<endl;

   

   

 }