#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cctype>

#include <algorithm>
#include <random>
#include <bitset>
#include <queue>
#include <functional>
#include <set>
#include <map>
#include <vector>
#include <chrono>
#include <iostream>
#include <limits>
#include <numeric>

#define LOG(FMT...) fprintf(stderr, FMT)

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

template<class T>
istream &operator>>(istream &is, vector<T> &v) {
  for (T &x : v)
    is >> x;
  return is;
}

template<class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
  if (!v.empty()) {
    os << v.front();
    for (int i = 1; i < v.size(); ++i)
      os << ' ' << v[i];
  }
  return os;
}

const int P = 1000000007;

int norm(int x) { return x >= P ? (x - P) : x; }

void add(int &x, int y) { if ((x += y) >= P) x -= P; }

void sub(int &x, int y) { if ((x -= y) < 0) x += P; }

void exGcd(int a, int b, int &x, int &y) {
  if (!b) {
    x = 1;
    y = 0;
    return;
  }
  exGcd(b, a % b, y, x);
  y -= a / b * x;
}

int inv(int a) {
  int x, y;
  exGcd(a, P, x, y);
  return norm(x + P);
}

struct Info {
  int x[2][2];

  Info() { memset(x, 0, sizeof(x)); }

  Info(const Info &info) { memcpy(x, info.x, sizeof(x)); }

  Info operator+(const Info &rhs) const {
    Info ret = Info();
    for (int i = 0; i < 2; ++i)
      for (int j = 0; j < 2; ++j)
        ret.x[i][j] = norm(x[i][j] + rhs.x[i][j]);
    return ret;
  }

  Info operator*(const Info &rhs) const {
    Info ret = Info();
    for (int i = 0; i < 2; ++i)
      for (int j = 0; i + j < 2; ++j)
        for (int k = 0; k < 2; ++k)
          for (int t = 0; t < 2; ++t)
            add(ret.x[i + j][k | t], x[i][k] * (ll) rhs.x[j][t] % P);
    return ret;
  }

  void swp() {
    for (int i = 0; i < 2; ++i) swap(x[i][0], x[i][1]);
  }
};

Info id() {
  Info ret = Info();
  ret.x[0][0] = 1;
  return ret;
}

struct Mat {
  int x[2][2];

  Mat() { memset(x, 0, sizeof(x)); }

  Mat(const Mat &mat) { memcpy(x, mat.x, sizeof(x)); }

  Mat operator*(const Mat& rhs) const {
    Mat ret = Mat();
    for (int i = 0; i < 2; ++i)
      for (int j = 0; j < 2; ++j)
        for (int k = 0; k < 2; ++k)
          ret.x[i][k] = (ret.x[i][k] + x[i][j] * (ll)rhs.x[j][k]) % P;
    return ret;
  }
};

Mat matExp(const Mat& mat, ll d) {
  if (d == 1) return mat;
  Mat half = matExp(mat * mat, d >> 1);
  if (d & 1) half = half * mat;
  return half;
}

int main() {
#ifdef ELEGIA
  freopen("test.in", "r", stdin);
  int nol_cl = clock();
#endif
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  int n;
  ll d;
  cin >> n >> d;

  vector<vector<int>> g(n);
  for (int rep = 1; rep < n; ++rep) {
    int u, v;
    cin >> u >> v;
    --u;
    --v;
    g[u].push_back(v);
    g[v].push_back(u);
  }

  vector<vector<int>> tree(n);

  vector<int> prt(n, -1);
  function<void(int)> predfs = [&](int u) {
    for (int v : g[u])
      if (v != prt[u]) {
        prt[v] = u;
        tree[u].push_back(v);
        predfs(v);
      }
  };
  predfs(0);

  auto getDP = [&](int x, int y) {
    vector<Info> dt(n), td(n), ret(n);
    Info ad = Info();
    ad.x[0][0] = 1;
    ad.x[1][0] = x;
    ad.x[1][1] = y;

    function<void(int)> downtop = [&](int u) {
      dt[u] = ad;
      for (int v : tree[u])
        dt[u] = dt[u] * (downtop(v), dt[v]);
      dt[u].swp();
    };
    downtop(0);

    td[0] = id();
    function<void(int)> topdown = [&](int u) {
      if (tree[u].empty())
        return;
      {
        vector<Info> pre(tree[u].size()), suf(tree[u].size());
        Info cur = id();
        for (int i = 0; i < tree[u].size(); ++i) {
          pre[i] = cur;
          cur = cur * dt[tree[u][i]];
        }
        cur = id();
        for (int i = (int) tree[u].size() - 1; i >= 0; --i) {
          suf[i] = cur;
          cur = cur * dt[tree[u][i]];
        }
        for (int i = 0; i < tree[u].size(); ++i) {
          td[tree[u][i]] = td[u] * pre[i] * suf[i] * ad;
          td[tree[u][i]].swp();
          td[tree[u][i]] = td[tree[u][i]];
        }
      }
      for (int v : tree[u])
        topdown(v);
    };
    topdown(0);

    for (int u = 0; u < n; ++u) {
      ret[u] = ad;
      for (int v : g[u])
        if (v != prt[u])
          ret[u] = ret[u] * dt[v];
        else
          ret[u] = ret[u] * td[u];
      ret[u].swp();
    }

    return ret;
  };

  auto trans0 = getDP(1, 0);
  auto trans1 = getDP(0, 1);

  Mat transMat = Mat();
  int row0 = 0, row1 = 0;
  for (int i = 0; i < n; ++i) {
    add(row0, trans0[i].x[0][0]);
    add(row1, trans0[i].x[0][1]);
    add(transMat.x[0][0], trans0[i].x[1][0]);
    add(transMat.x[0][1], trans0[i].x[1][1]);
    add(transMat.x[1][0], trans1[i].x[1][0]);
    add(transMat.x[1][1], trans1[i].x[1][1]);
  }
  int fin0 = row0, fin1 = row1;
  if (d > 1) {
    Mat ex = matExp(transMat, d - 1);
    fin0 = (row0 * (ll) ex.x[0][0] + row1 * (ll) ex.x[1][0]) % P;
    fin1 = (row0 * (ll) ex.x[0][1] + row1 * (ll) ex.x[1][1]) % P;
  }

  int ans = getDP(fin0, fin1)[0].x[1][0];
  cout << ans << '\n';

#ifdef ELEGIA
  LOG("Time: %dms\n", int ((clock()
          -nol_cl) / (double)CLOCKS_PER_SEC * 1000));
#endif
  return 0;
}