In one very old text file there was written Great Wisdom. This Wisdom was so Great that nobody could decipher it, even Phong — the oldest among the inhabitants of Mainframe. But still he managed to get some information from there. For example, he managed to learn that User launches games for pleasure — and then terrible Game Cubes fall down on the city, bringing death to those modules, who cannot win the game...

For sure, as guard Bob appeared in Mainframe many modules stopped fearing Game Cubes. Because Bob (as he is alive yet) has never been defeated by User, and he always meddles with Game Cubes, because he is programmed to this.

However, unpleasant situations can happen, when a Game Cube falls down on Lost Angles. Because there lives a nasty virus — Hexadecimal, who is... mmm... very strange. And she likes to play very much. So, willy-nilly, Bob has to play with her first, and then with User.

This time Hexadecimal invented the following entertainment: Bob has to leap over binary search trees with *n* nodes. We should remind you that a binary search tree is a binary tree, each node has a distinct key, for each node the following is true: the left sub-tree of a node contains only nodes with keys less than the node's key, the right sub-tree of a node contains only nodes with keys greater than the node's key. All the keys are different positive integer numbers from 1 to *n*. Each node of such a tree can have up to two children, or have no children at all (in the case when a node is a leaf).

In Hexadecimal's game all the trees are different, but the height of each is not lower than *h*. In this problem «height» stands for the maximum amount of nodes on the way from the root to the remotest leaf, the root node and the leaf itself included. When Bob leaps over a tree, it disappears. Bob gets the access to a Cube, when there are no trees left. He knows how many trees he will have to leap over in the worst case. And you?
The input data contains two space-separated positive integer numbers *n* and *h* (*n* ≤ 35, *h* ≤ *n*).
none
3 2
5
3 3
4
1 1
1
2 1
2
2 2
2
27 11
61162698256896
32 27
22643872890880
4 1
14
9 1
4862
33 4
212336130412243110
4 4
8
8 5
1336
12 8
127200
15 5
9694844
19 18
2424832
23 17
19649347584
27 15
25162319484928
29 14
577801978306560
33 18
54307238601375744
7 7
64
23 21
275251200
7 3
429
21 18
211156992
4 1
14
21 12
12153990144
35 13
2690352397519398400
19 2
1767263190
33 26
434871797284864
16 9
25607552
16 14
1032192
10 2
16796
4 4
8
33 17
75307983624118272
27 25
6081740800
20 14
1094473728
16 11
11819008
10 10
512
4 3
14
33 21
14830955929665536
24 20
8171945984
30 16
1375710400053248
3 2
5
9 4
4862
16 5
35357670
22 22
2097152
28 23
739948625920
34 1
812944042149730764
7 4
428
14 11
488448
35 1
3116285494907301262
35 35
17179869184
import sys
input = sys.stdin.readline

m = 36
dp = [[0] * m for _ in range(36)]
dp[1][1] = 1
for i in range(2, m):
    for j in range(2, i + 1):
        dp[i][j] = 2 * dp[i - 1][j - 1]
    for x in range(1, i - 1):
        y = i - x - 1
        dpx, dpy = dp[x], dp[y]
        for j in range(1, x + 1):
            for k in range(1, y + 1):
                dp[i][1 + max(j, k)] += dpx[j] * dpy[k]
n, h = map(int, input().split())
ans = 0
dpn = dp[n]
for i in range(h, m):
    ans += dpn[i]
print(ans)