Ostap already settled down in Rio de Janiero suburb and started to grow a tree in his garden. Recall that a tree is a connected undirected acyclic graph. 

Ostap's tree now has n vertices. He wants to paint some vertices of the tree black such that from any vertex u there is at least one black vertex v at distance no more than k. Distance between two vertices of the tree is the minimum possible number of edges of the path between them.

As this number of ways to paint the tree can be large, Ostap wants you to compute it modulo 109 + 7. Two ways to paint the tree are considered different if there exists a vertex that is painted black in one way and is not painted in the other one.

Input

The first line of the input contains two integers n and k (1 ≤ n ≤ 100, 0 ≤ k ≤ min(20, n - 1)) — the number of vertices in Ostap's tree and the maximum allowed distance to the nearest black vertex. Don't miss the unusual constraint for k.

Each of the next n - 1 lines contain two integers ui and vi (1 ≤ ui, vi ≤ n) — indices of vertices, connected by the i-th edge. It's guaranteed that given graph is a tree.

Output

Print one integer — the remainder of division of the number of ways to paint the tree by 1 000 000 007 (109 + 7).

Examples

Input

2 0
1 2


Output

1


Input

2 1
1 2


Output

3


Input

4 1
1 2
2 3
3 4


Output

9


Input

7 2
1 2
2 3
1 4
4 5
1 6
6 7


Output

91

Note

In the first sample, Ostap has to paint both vertices black.

In the second sample, it is enough to paint only one of two vertices, thus the answer is 3: Ostap can paint only vertex 1, only vertex 2, vertices 1 and 2 both.

In the third sample, the valid ways to paint vertices are: {1, 3}, {1, 4}, {2, 3}, {2, 4}, {1, 2, 3}, {1, 2, 4}, {1, 3, 4}, {2, 3, 4}, {1, 2, 3, 4}.
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Jialin Ouyang (Jialin.Ouyang@gmail.com)
 */
public class Main {
  public static void main(String[] args) {
    InputStream inputStream = System.in;
    OutputStream outputStream = System.out;
    QuickScanner in = new QuickScanner(inputStream);
    QuickWriter out = new QuickWriter(outputStream);
    TaskC solver = new TaskC();
    solver.solve(1, in, out);
    out.close();
  }

  static class TaskC {
    int n;
    int k;
    int k2;
    Tree tree;
    int[][] way;
    int[][] tmpWay;

    public void solve(int testNumber, QuickScanner in, QuickWriter out) {
      n = in.nextInt();
      k = in.nextInt();
      if (k == 0) {
        out.println(1);
        return;
      }
      tree = new Tree(n);
      for (int i = 1; i < n; ++i) {
        tree.add(in.nextInt() - 1, in.nextInt() - 1);
      }
      k2 = (k + 1) << 1;
      way = new int[n][k2];
      tmpWay = new int[2][k2];
//    way = new int[n][k + 2][k + 2];
//    tmpWay = new int[2][k + 2][k + 2];
      dfs(0, -1);
      int res = 0;
      for (int i = 0; i <= k + 1; ++i) {
        res = IntUtils.add(res, way[0][i]);
      }
      out.println(res);
//    System.out.printf("k: %d\n", k);
//    for (int i = 0; i < n; ++i) for (int j = 0; j < k2; ++j) if (way[i][j] > 0) {
//      if (j < k + 1) {
//        System.out.printf("way[%d] black[%d]: %d\n", i, j + 1, way[i][j]);
//      } else if (j == k + 1) {
//        System.out.printf("way[%d] empty: %d\n", i, way[i][j]);
//      } else {
//        System.out.printf("way[%d] white[%d]: %d\n", i, j - k - 1, way[i][j]);
//      }
//    }
    }

    void dfs(int u, int parent) {
      for (int edgeIdx = tree.lastOut(u); edgeIdx >= 0; edgeIdx = tree.nextOut(edgeIdx)) {
        int v = tree.toIdx(edgeIdx);
        if (v == parent) continue;
        dfs(v, u);
      }
//System.out.printf("====u:%d====\n", u);
      int t = 0;
      clear(tmpWay[t]);
      tmpWay[t][0] = tmpWay[t][k + 2] = 1;
//    clear(tmpWay[t]);
//    tmpWay[t][0][1] = tmpWay[t][1][0] = 1;
      for (int edgeIdx = tree.lastOut(u); edgeIdx >= 0; edgeIdx = tree.nextOut(edgeIdx)) {
        int v = tree.toIdx(edgeIdx);
        if (v == parent) continue;
        clear(tmpWay[t ^ 1]);
        append(tmpWay[t], way[v], tmpWay[t ^ 1]);
        t ^= 1;
      }
      System.arraycopy(tmpWay[t], 0, way[u], 0, k2);
//    for (int black = 0; black <= k + 1; ++black) for (int white = 0; white <= k + 1; ++white) {
//      way[u][black][white] = tmpWay[t][black][white];
//    }
    }

    void clear(int[] way) {
      Arrays.fill(way, 0, k2, 0);
    }

    void append(int[] way, int[] childWay, int[] resWay) {
      for (int i = 0; i < k2; ++i)
        if (way[i] > 0) {
          int black = i < k + 1 ? i + 1 : 0;
          int white = i > k + 1 ? i - k - 1 : 0;
          for (int j = 0; j < k2; ++j)
            if (childWay[j] > 0) {
              int value = IntUtils.mul(way[i], childWay[j]);
              int childBlack = j < k + 1 ? j + 1 : 0;
              int childWhite = j > k + 1 ? j - k - 1 : 0;
              int resBlack;
              if (black > 0 && childBlack > 0) {
                resBlack = Math.min(black, childBlack + 1);
              } else if (black > 0) {
                resBlack = black;
              } else if (childBlack > 0) {
                resBlack = childBlack > k ? 0 : childBlack + 1;
              } else {
                resBlack = 0;
              }
              int resWhite;
              if (white > 0 && childWhite > 0) {
                resWhite = Math.max(white, childWhite + 1);
              } else if (white > 0) {
                resWhite = white;
              } else if (childWhite > 0) {
                resWhite = childWhite + 1;
              } else {
                resWhite = 0;
              }
              if (resBlack > 0 && resWhite <= k + 2 - resBlack) {
                resWhite = 0;
              }
              if (resWhite > 0) {
                if (resWhite <= k) {
                  resWay[resWhite + k + 1] = IntUtils.add(resWay[resWhite + k + 1], value);
                }
              } else if (resBlack > 0) {
                resWay[resBlack - 1] = IntUtils.add(resWay[resBlack - 1], value);
              } else {
                resWay[k + 1] = IntUtils.add(resWay[k + 1], value);
              }
            }
        }
    }

  }

  static abstract class AbstractTree extends AbstractBidirectionalGraph implements TreeInterface {
    public AbstractTree(int vertexCapacity) {
      super(vertexCapacity, vertexCapacity - 1);
    }

  }

  static interface TreeInterface extends BidirectionalGraphInterface {
  }

  static class Tree extends AbstractTree {
    public Tree(int vertexCapacity) {
      super(vertexCapacity);
    }


    public void createSubclass(int vertexCapacity, int edgeCapacity) {
    }


    public void initSubclass(int vertexCnt) {
    }

  }

  static class QuickWriter {
    private final PrintWriter writer;

    public QuickWriter(OutputStream outputStream) {
      this.writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public QuickWriter(Writer writer) {
      this.writer = new PrintWriter(writer);
    }

    public void print(Object... objects) {
      for (int i = 0; i < objects.length; ++i) {
        if (i > 0) {
          writer.print(' ');
        }
        writer.print(objects[i]);
      }
    }

    public void println(Object... objects) {
      print(objects);
      writer.print('\n');
    }

    public void close() {
      writer.close();
    }

  }

  static class IntUtils {
    public static int MOD = 1000000007;

    public static int add(int a, int b) {
      return add(a, b, MOD);
    }

    public static int add(int a, int b, int mod) {
      return slightFix(a + b, mod);
    }

    public static int mul(int a, int b) {
      return mul(a, b, MOD);
    }

    public static int mul(int a, int b, int mod) {
      return a > 0
          ? (b < mod / a
          ? a * b
          : (int) ((long) a * b % mod))
          : 0;
    }

    private static int slightFix(int a, int mod) {
      return a >= mod
          ? a - mod
          : a < 0
          ? a + mod
          : a;
    }

  }

  static abstract class AbstractBidirectionalGraph extends AbstractDirectedGraph implements BidirectionalGraphInterface {
    public AbstractBidirectionalGraph(int vertexCapacity, int edgeCapacity) {
      super(vertexCapacity, edgeCapacity << 1);
    }

    public AbstractBidirectionalGraph(int vertexCapacity, int edgeCapacity, boolean initialize) {
      super(vertexCapacity, edgeCapacity << 1, initialize);
    }


    public void add(int u, int v) {
      super.add(u, v);
      super.add(v, u);
    }

  }

  static class QuickScanner {
    private static final int BUFFER_SIZE = 1024;
    private InputStream stream;
    private byte[] buffer;
    private int currentPosition;
    private int numberOfChars;

    public QuickScanner(InputStream stream) {
      this.stream = stream;
      this.buffer = new byte[BUFFER_SIZE];
      this.currentPosition = 0;
      this.numberOfChars = 0;
    }

    public int nextInt() {
      int c = nextNonSpaceChar();
      boolean positive = true;
      if (c == '-') {
        positive = false;
        c = nextChar();
      }
      int res = 0;
      do {
        if (c < '0' || '9' < c) throw new RuntimeException();
        res = res * 10 + c - '0';
        c = nextChar();
      } while (!isSpaceChar(c));
      return positive ? res : -res;
    }

    public int nextNonSpaceChar() {
      int res = nextChar();
      for (; isSpaceChar(res) || res < 0; res = nextChar()) ;
      return res;
    }

    public int nextChar() {
      if (numberOfChars == -1) {
        throw new RuntimeException();
      }
      if (currentPosition >= numberOfChars) {
        currentPosition = 0;
        try {
          numberOfChars = stream.read(buffer);
        } catch (Exception e) {
          throw new RuntimeException(e);
        }
        if (numberOfChars <= 0) {
          return -1;
        }
      }
      return buffer[currentPosition++];
    }

    public boolean isSpaceChar(int c) {
      return c == ' ' || c == '\t' || isEndOfLineChar(c);
    }

    public boolean isEndOfLineChar(int c) {
      return c == '\n' || c == '\r' || c < 0;
    }

  }

  static abstract class AbstractDirectedGraph implements DirectedGraphInterface {
    protected int vertexCnt;
    protected int currentEdgeCnt;
    protected int[] fromIdx;
    protected int[] toIdx;
    protected int[] nextIn;
    protected int[] nextOut;
    protected int[] lastIn;
    protected int[] lastOut;
    protected int[] inDegree;
    protected int[] outDegree;

    public abstract void createSubclass(int vertexCapacity, int edgeCapacity);

    public abstract void initSubclass(int vertexCnt);

    public AbstractDirectedGraph(int vertexCapacity, int edgeCapacity) {
      this(vertexCapacity, edgeCapacity, true);
    }

    public AbstractDirectedGraph(int vertexCapacity, int edgeCapacity, boolean initialize) {
      fromIdx = new int[edgeCapacity];
      toIdx = new int[edgeCapacity];
      lastIn = new int[vertexCapacity];
      lastOut = new int[vertexCapacity];
      nextIn = new int[edgeCapacity];
      nextOut = new int[edgeCapacity];
      inDegree = new int[vertexCapacity];
      outDegree = new int[vertexCapacity];
      createSubclass(vertexCapacity, edgeCapacity);
      if (initialize) init(vertexCapacity);
    }


    public void init(int vertexCnt) {
      this.vertexCnt = vertexCnt;
      currentEdgeCnt = 0;
      Arrays.fill(inDegree, 0, vertexCnt, 0);
      Arrays.fill(outDegree, 0, vertexCnt, 0);
      Arrays.fill(lastIn, 0, vertexCnt, -1);
      Arrays.fill(lastOut, 0, vertexCnt, -1);
      initSubclass(vertexCnt);
    }


    public void add(int fromIdx, int toIdx) {
      this.fromIdx[currentEdgeCnt] = fromIdx;
      this.toIdx[currentEdgeCnt] = toIdx;
      ++outDegree[fromIdx];
      ++inDegree[toIdx];
      nextOut[currentEdgeCnt] = lastOut[fromIdx];
      lastOut[fromIdx] = currentEdgeCnt;
      nextIn[currentEdgeCnt] = lastIn[toIdx];
      lastIn[toIdx] = currentEdgeCnt;
      ++currentEdgeCnt;
    }


    public int toIdx(int edgeIdx) {
      return toIdx[edgeIdx];
    }


    public int lastOut(int nodeIdx) {
      return lastOut[nodeIdx];
    }


    public int nextOut(int edgeIdx) {
      return nextOut[edgeIdx];
    }

  }

  static interface DirectedGraphInterface {
  }

  static interface BidirectionalGraphInterface extends DirectedGraphInterface {
  }
}

