Dima loves making pictures on a piece of squared paper. And yet more than that Dima loves the pictures that depict one of his favorite figures. 

A piece of squared paper of size *n* × *m* is represented by a table, consisting of *n* rows and *m* columns. All squares are white on blank squared paper. Dima defines a picture as an image on a blank piece of paper, obtained by painting some squares black.

The picture portrays one of Dima's favorite figures, if the following conditions hold:
 -  The picture contains at least one painted cell; -  All painted cells form a connected set, that is, you can get from any painted cell to any other one (you can move from one cell to a side-adjacent one); -  The minimum number of moves needed to go from the painted cell at coordinates (*x*<sub class="lower-index">1</sub>, *y*<sub class="lower-index">1</sub>) to the painted cell at coordinates (*x*<sub class="lower-index">2</sub>, *y*<sub class="lower-index">2</sub>), moving only through the colored cells, equals |*x*<sub class="lower-index">1</sub> - *x*<sub class="lower-index">2</sub>| + |*y*<sub class="lower-index">1</sub> - *y*<sub class="lower-index">2</sub>|. 
Now Dima is wondering: how many paintings are on an *n* × *m* piece of paper, that depict one of his favorite figures? Count this number modulo 1000000007 (10<sup class="upper-index">9</sup> + 7).
The first line contains two integers *n* and *m* — the sizes of the piece of paper (1 ≤ *n*, *m* ≤ 150).
import sys

MOD = 10 ** 9 + 7 # needs to be prime!

n, m = [int(x) for x in input().split()]

if n > m:
    n,m = m,n

DP = []
for il in range(2):
    A = []
    DP.append(A)
    for ir in range(2):
        B = [[]]
        A.append(B)

        for mm in range(1, m + 1):
            C = []
            B.append(C)

            B0i = DP[0][ir][mm]
            Bi0 = DP[il][0][mm]
            B00 = DP[0][0][mm]

            presum = []

            for r in range(n):
                D = [0] * (r + 1)
                C.append(D)

                for l in range(r + 1):
                    if mm == 1:
                        D[l] = 1
                        continue

                    ans = 0
                    
                    if il and l + 1 <= r:
                        ans += B0i[r][l + 1]
                        #ans += DP[False][ir][mm][r][l + 1]
                            #ans += solve(l + 1, r, m, False, ir)

                    if ir and l <= r - 1:
                        ans += Bi0[r - 1][l]
                        #ans += DP[il][False][mm][r - 1][l]
                            #ans += solve(l, r - 1, m, il, False)

                    if il and ir and l + 1 <= r - 1:
                        ans -= B00[r - 1][l + 1]
                        #ans -= DP[False][False][mm][r - 1][l + 1]
                            #ans -= solve(l + 1, r - 1, m, False, False)

                    R = range(r, n) if ir else range(l, r + 1)

                    for r2 in R[::-1]:
                        #BB = B[mm - 1][r2]
                        BBpresum = old_presum[r2]

                        a,b = (0, l + 1) if il else (l, min(r, r2) + 1)
                        ans += BBpresum[b] - BBpresum[a]

                        #L = range(0, l + 1) if il else range(l, min(r,r2) + 1)
                        #for l2 in L:
                            #ans += BB[l2]
                            #ans += solve(l2,r2,m-1,il,ir)
                    D[l] = ans % MOD
                
                Dpresum = [0]
                for d in D:
                    Dpresum.append((Dpresum[-1] + d) % MOD)

                presum.append(Dpresum)
            old_presum = presum


ans = 0
for j in range(n):
    for i in range(j + 1):
        for mm in range(1, m + 1):
            ans += (m - mm + 1) * DP[1][1][mm][j][i]
            #ans += (m - mm + 1) * solve(i,j,mm)

print(ans % MOD)