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).
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.math.BigInteger;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.util.StringTokenizer;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author shu_mj @ http://shu-mj.com
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		Scanner in = new Scanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    Scanner in;
    PrintWriter out;

    public void solve(int testNumber, Scanner in, PrintWriter out) {
        this.in = in;
        this.out = out;
        run();
    }

    void run() {
        int n = in.nextInt();
        int t = in.nextInt();
        int[][][][] dp = new int[n + 1][t + 1][4][2];
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) if (i < j) {
                dp[2][0][j][0]++;
            }
        }
        for (int i = 2; i < n; i++) {
            for (int j = 0; j <= t; j++) {
                for (int k = 0; k < 4; k++) {
                    for (int l = 0; l < 2; l++) if (dp[i][j][k][l] > 0) {
                        int old = dp[i][j][k][l];
                        for (int u = 0; u < 4; u++) if (u != k) {
                            if ((l == 0) ^ (u < k)) {
                                dp[i + 1][j][u][l] += old;
                            } else {
                                if (l == 1) dp[i + 1][j][u][l ^ 1] += old;
                                else if (j < t) dp[i + 1][j + 1][u][l ^ 1] += old;
                            }
                        }
                    }
                }
            }
        }
        int res = 0;
        for (int k = 0; k < 4; k++) {
            res += dp[n][t][k][1];
        }
        out.println(res);
    }
}

class Scanner {
    BufferedReader br;
    StringTokenizer st;

    public Scanner(InputStream in) {
        br = new BufferedReader(new InputStreamReader(in));
        eat("");
    }

    private void eat(String s) {
        st = new StringTokenizer(s);
    }

    public String nextLine() {
        try {
            return br.readLine();
        } catch (IOException e) {
            return null;
        }
    }

    public boolean hasNext() {
        while (!st.hasMoreTokens()) {
            String s = nextLine();
            if (s == null)
                return false;
            eat(s);
        }
        return true;
    }

    public String next() {
        hasNext();
        return st.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

}

		 						  	  	  	 	 		     		