Bob likes to draw camels: with a single hump, two humps, three humps, etc. He draws a camel by connecting points on a coordinate plane. Now he's drawing camels with t humps, representing them as polylines in the plane. Each polyline consists of n vertices with coordinates (x1, y1), (x2, y2), ..., (xn, yn). The first vertex has a coordinate x1 = 1, the second — x2 = 2, etc. Coordinates yi might be any, but should satisfy the following conditions:

  * there should be t humps precisely, i.e. such indexes j (2 ≤ j ≤ n - 1), so that yj - 1 < yj > yj + 1, 
  * there should be precisely t - 1 such indexes j (2 ≤ j ≤ n - 1), so that yj - 1 > yj < yj + 1, 
  * no segment of a polyline should be parallel to the Ox-axis, 
  * all yi are integers between 1 and 4. 



For a series of his drawings of camels with t humps Bob wants to buy a notebook, but he doesn't know how many pages he will need. Output the amount of different polylines that can be drawn to represent camels with t humps for a given number n.

Input

The first line contains a pair of integers n and t (3 ≤ n ≤ 20, 1 ≤ t ≤ 10).

Output

Output the required amount of camels with t humps.

Examples

Input

6 1


Output

6


Input

4 2


Output

0

Note

In the first sample test sequences of y-coordinates for six camels are: 123421, 123431, 123432, 124321, 134321 и 234321 (each digit corresponds to one value of yi).
/**
 * @author Anil Kishore, IIIT-Hyderabad
 * May, 2010
 */

import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class CF14_E
{
    BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
    PrintWriter stdout = new PrintWriter(new OutputStreamWriter(System.out));
    StringTokenizer st;
    StringBuilder sb = new StringBuilder();

    long[][][][][] dp = new long[21][11][11][5][5];
    int N, T ;

    long get(int cp,int up,int down,int pp,int p)
    {
        if(cp==N+1) return (up==0 && down==0) ? 1 : 0;
        if(up<0 || down<0) return 0;
        long res = dp[cp][up][down][pp][p];
        if(res!=-1) return res;
        res = 0;

        for(int i=1;i<=4;i++)
        {
            if(i==p) continue;
            int upx = up, downx = down;
            if(p<pp && p<i) downx--;
            if(p>pp && p>i) upx--;
            res+=get(cp+1,upx,downx,p,i);
        }

        return dp[cp][up][down][pp][p] = res;
    }

    void solve() throws IOException
    {
        N = INT(); T = INT();

        for(int i=0;i<=N;i++) for(int j=0;j<=T;j++) for(int k=0;k<=T;k++) for(int l=1;l<=4;l++)
            dp[i][j][k][l][1]=dp[i][j][k][l][2]=dp[i][j][k][l][3]=dp[i][j][k][l][4]=-1;

        long res = 0;

        for(int i=1;i<=4;i++) for(int j=1;j<=4;j++)
                if(i!=j) res+=get(3,T,T-1,i,j);

        stdout.println(res);

        stdin.close();
        stdout.flush();
        stdout.close();
    }

    final int INT() throws IOException
    {
        return Integer.parseInt(TOK());
    }

    final String TOK() throws IOException
    {
        if(st==null || !st.hasMoreTokens()) st = new StringTokenizer(stdin.readLine());
        return st.nextToken();
    }

    public static void main(String[] args) throws IOException
    {
        (new CF14_E()).solve();
    }
}