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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.Arrays;

public class CT14E {

	static StreamTokenizer in;
	static PrintWriter out;
	
	static int nextInt() throws IOException {
		in.nextToken();
		return (int)in.nval;
	}
	
	static String nextString() throws IOException {
		in.nextToken();
		return in.sval;
	}

	public static void main(String[] args) throws IOException {
		in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		out = new PrintWriter(System.out);

		//for (int t = nextInt(); t > 0; t--) {
			n = nextInt();
			k = nextInt();
			
			long ans = 0;
			for (int a = 0; a < 4; a++)
				for (int b = 0; b < 4; b++)
					if (a != b)
						ans += solve(n-2, k, k-1, a, b);
			
			out.println(ans);
		//}
		
		out.flush();
	}

	static int n, k;
	static long[][][][][] memo = new long[20][11][11][4][4];
	static {
		for (long[][][][] a : memo)
			for (long[][][] b : a)
				for (long[][] c : b)
					for (long[] d : c)
						Arrays.fill(d, -1);
	}
	
	static long solve(int x, int q, int p, int a, int b) {
		if (x == 0) return q == 0 && p == 0 ? 1 : 0;
		if (q < 0 || p < 0) return 0;
		if (memo[x][q][p][a][b] != -1) return memo[x][q][p][a][b];
		
		int res = 0;
		for (int i = 0; i < 4; i++)
			if (i < a && a > b) res += solve(x-1, q-1, p, i, a);
			else if (i > a && a < b) res += solve(x-1, q, p-1, i, a);
			else if (i != a) res += solve(x-1, q, p, i, a);
		
		return memo[x][q][p][a][b] = res;
	}
}
