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 (x1, y1) to the painted cell at coordinates (x2, y2), moving only through the colored cells, equals |x1 - x2| + |y1 - y2|. 



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 (109 + 7).

Input

The first line contains two integers n and m — the sizes of the piece of paper (1 ≤ n, m ≤ 150).

Output

In a single line print the remainder after dividing the answer to the problem by number 1000000007 (109 + 7).

Examples

Input

2 2


Output

13


Input

3 4


Output

571
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;

/**
 * Created by hama_du on 15/09/09.
 */
public class D {
    private static final long MOD = 1000000007;

    public static void main(String[] args) {
        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int n = in.nextInt();
        int m = in.nextInt();

        long[][][][] dp = new long[4][n][m+1][m+1];
        for (int fr = 0; fr < m; fr++) {
            for (int to = fr; to < m; to++) {
                dp[0][0][fr][to] = 1;
            }
        }
        for (int r = 1 ; r < n ; r++) {
            long[][][] imos = new long[4][m+1][m+1];
            for (int flg = 0; flg <= 3; flg++) {
                for (int fr = 0; fr < m; fr++) {
                    for (int to = 0; to < m; to++) {
                        imos[flg][fr+1][to+1] = imos[flg][fr+1][to] + imos[flg][fr][to+1] - imos[flg][fr][to] + dp[flg][r-1][fr][to];
                        imos[flg][fr+1][to+1] += MOD * 10;
                        imos[flg][fr+1][to+1] %= MOD;
                    }
                }
            }

            for (int tfr = 0; tfr < m; tfr++) {
                for (int tto = tfr ; tto < m ; tto++) {
                    for (int flg = 0; flg <= 3; flg++) {
                        long val = 0;
                        if (flg == 0) {
                            // [0] fr >= tfr, to <= tto
                            val += range(imos[0], tfr, m-1, 0, tto);
                        } else if (flg == 1) {
                            // [0] fr < tfr, to <= tto
                            val += range(imos[0], 0, tfr-1, tfr, tto);

                            // [1] fr <= tfr, to <= tto
                            val += range(imos[1], 0, tfr, tfr, tto);
                        } else if (flg == 2) {
                            // [0] fr >= tfr, to > tto
                            val += range(imos[0], tfr, tto, tto+1, m-1);

                            // [2] fr >= tfr, to >= tto
                            val += range(imos[2], tfr, tto, tto, m-1);
                        } else {
                            // [0] fr < tfr, to > tto
                            val += range(imos[0], 0, tfr-1, tto+1, m-1);

                            // [1] fr <= tfr, to > tto
                            val += range(imos[1], 0, tfr, tto+1, m-1);

                            // [2] fr < tfr, to >= tto
                            val += range(imos[2], 0, tfr-1, tto, m-1);

                            // [3] fr <= tfr, to >= tto
                            val += range(imos[3], 0, tfr, tto, m-1);
                        }
                        val %= MOD;
                        dp[flg][r][tfr][tto] = val;
                    }
                }
            }
        }

        long sum = 0;
        for (int r = 0 ; r < n ; r++) {
            for (int fr = 0; fr < m; fr++) {
                for (int to = fr ; to < m; to++) {
                    for (int flg = 0 ; flg <= 3; flg++) {
                        sum += (dp[flg][r][fr][to]) * (n-r);
                    }
                }
            }
            sum %= MOD;
        }

        out.println(sum);
        out.flush();
    }

    // compute range sum(both inclusive)
    static long range(long[][] imos, int frX, int toX, int frY, int toY) {
        return (imos[toX+1][toY+1] - imos[toX+1][frY] - imos[frX][toY+1] + imos[frX][frY] + MOD * 10);
    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        private int next() {
            if (numChars == -1)
                throw new InputMismatchException();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public char nextChar() {
            int c = next();
            while (isSpaceChar(c))
                c = next();
            if ('a' <= c && c <= 'z') {
                return (char) c;
            }
            if ('A' <= c && c <= 'Z') {
                return (char) c;
            }
            throw new InputMismatchException();
        }

        public String nextToken() {
            int c = next();
            while (isSpaceChar(c))
                c = next();
            StringBuilder res = new StringBuilder();
            do {
                res.append((char) c);
                c = next();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public int nextInt() {
            int c = next();
            while (isSpaceChar(c))
                c = next();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = next();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c-'0';
                c = next();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public long nextLong() {
            int c = next();
            while (isSpaceChar(c))
                c = next();
            long sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = next();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c-'0';
                c = next();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }

    static void debug(Object... o) {
        System.err.println(Arrays.deepToString(o));
    }
}
