#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long LINF = 2e16;
const long long INF = 2e9;
const long long magic = 348;
const double eps = 1e-10;
const double pi = acos(-1);
inline long long getint() {
  char ch;
  long long res;
  bool f;
  while (!isdigit(ch = getchar()) && ch != '-') {
  }
  if (ch == '-')
    f = false, res = 0;
  else
    f = true, res = ch - '0';
  while (isdigit(ch = getchar())) res = res * 10 + ch - '0';
  return f ? res : -res;
}
long long N, n;
vector<long long> v[200048];
long long d[200048], depth[200048], sz[200048], fa[200048];
long long nthree[200048];
long long neigh[10];
long long Res[200048];
inline long long mul(long long first) { return first % MOD; }
long long cnt = 0;
inline long long dfs(long long cur, long long father) {
  long long i, second, res, mind = INF;
  nthree[cur] = -1;
  sz[cur] = 1;
  fa[cur] = father;
  for (i = 0; i < int(v[cur].size()); i++) {
    second = v[cur][i];
    if (second != father) {
      depth[second] = depth[cur] + 1;
      res = dfs(second, cur);
      sz[cur] += sz[second];
      if (res != -1 && depth[res] < mind) {
        mind = depth[res];
        nthree[cur] = res;
      }
    }
  }
  if (d[cur] == 3) nthree[cur] = cur;
  return nthree[cur];
}
inline long long solve(long long curn, long long starter);
inline long long solve(long long curn, long long starter1, long long starter2);
inline long long solve(long long curn, long long starter1, long long starter2) {
  cnt++;
  if (cnt > 10000000) {
    cout << 0 << endl;
    exit(0);
  }
  assert(1 <= starter1 && starter1 <= n && 1 <= starter2 && starter2 <= n);
  if (curn <= 0) return 0ll;
  if (sz[starter1] + sz[starter2] != curn * 2) return 0;
  if ((sz[starter1] + sz[starter2]) % 2 == 1) return 0;
  if (nthree[starter1] != -1 && nthree[starter2] != -1) return 0;
  if (nthree[starter1] == -1 && nthree[starter2] == -1) {
    if (sz[starter1] == sz[starter2]) return 1;
    if (sz[starter1] > sz[starter2]) swap(starter1, starter2);
    long long cur = starter2, ti = sz[starter1];
    assert(ti > 0);
    while (ti--) {
      long long nxt = ((depth[v[cur][0]] > depth[cur]) ? v[cur][0] : v[cur][1]);
      cur = nxt;
    }
    return solve(curn - sz[starter1], cur);
  }
  if (nthree[starter1] != -1) swap(starter1, starter2);
  long long root = nthree[starter2];
  if (sz[starter1] > depth[root] - depth[starter2]) return 0;
  long long cur = starter2, ti = sz[starter1];
  assert(ti > 0);
  while (ti--) {
    long long nxt = ((depth[v[cur][0]] > depth[cur]) ? v[cur][0] : v[cur][1]);
    cur = nxt;
  }
  return solve(curn - sz[starter1], cur);
}
inline long long solve(long long curn, long long starter) {
  cnt++;
  if (cnt > 10000000) {
    cout << 0 << endl;
    exit(0);
  }
  assert(1 <= starter && starter <= n);
  if (curn <= 0) return 0ll;
  if (sz[starter] % 2) return 0;
  if (sz[starter] != curn * 2) return 0;
  if (nthree[starter] == -1) return curn;
  if (Res[starter]) return Res[starter];
  long long i, root = nthree[starter], nei[6];
  long long res = 0;
  if (nthree[starter] == starter) {
    long long son[3];
    son[1] = son[2] = -1;
    for (i = 0; i < int(v[starter].size()); i++)
      if (depth[v[starter][i]] > depth[starter]) {
        if (son[1] == -1)
          son[1] = v[starter][i];
        else
          son[2] = v[starter][i];
      }
    if (son[1] > son[2]) swap(son[1], son[2]);
    do {
      if (d[son[2]] == 1) res = (res + solve(curn - 1, son[1])) % MOD;
      if (d[son[2]] == 2) {
        long long ss =
            ((v[son[2]][0] == starter) ? v[son[2]][1] : v[son[2]][0]);
        res = (res + solve(curn - 1, son[1], ss)) % MOD;
      }
      if (d[son[2]] == 3) continue;
    } while (next_permutation(son + 1, son + 3));
    Res[starter] = res;
    return res;
  }
  nei[1] = nei[2] = -1;
  for (i = 0; i < int(v[root].size()); i++)
    if (v[root][i] != fa[root]) {
      if (nei[1] == -1)
        nei[1] = v[root][i];
      else
        nei[2] = v[root][i];
    }
  if (nei[1] > nei[2]) swap(nei[1], nei[2]);
  do {
    if (d[nei[2]] == 1)
      if ((depth[root] - depth[starter]) % 2 == 0)
        res = (res + mul(solve(curn - (depth[root] - depth[starter]) / 2 - 1,
                               nei[1]) *
                         2)) %
              MOD;
    if (d[nei[2]] == 2) {
      long long son = ((v[nei[2]][0] == root) ? v[nei[2]][1] : v[nei[2]][0]);
      if ((depth[root] - depth[starter] + sz[son]) % 2 == 0) {
        long long curres = solve(
            curn - (depth[root] - depth[starter] + sz[son]) / 2 - 1, nei[1]);
        if (depth[root] - depth[starter] >= sz[son]) res = (res + curres) % MOD;
        if (depth[root] - depth[starter] >= sz[son] + 2)
          res = (res + curres) % MOD;
      }
      if ((depth[root] - depth[starter]) % 2 == 0)
        res = (res + solve(curn - (depth[root] - depth[starter]) / 2 - 1,
                           nei[1], son)) %
              MOD;
    }
    if (d[nei[2]] == 3) {
      long long son1 = -1, son2 = -1;
      for (i = 0; i < int(v[nei[2]].size()); i++)
        if (v[nei[2]][i] != root)
          if (son1 == -1)
            son1 = v[nei[2]][i];
          else
            son2 = v[nei[2]][i];
      if ((depth[root] - depth[starter] + sz[son2]) % 2 == 0 &&
          depth[root] - depth[starter] >= sz[son2])
        res = (res +
               solve(curn - (depth[root] - depth[starter] + sz[son2]) / 2 - 1,
                     nei[1], son1)) %
              MOD;
      if ((depth[root] - depth[starter] + sz[son1]) % 2 == 0 &&
          depth[root] - depth[starter] >= sz[son1])
        res = (res +
               solve(curn - (depth[root] - depth[starter] + sz[son1]) / 2 - 1,
                     nei[1], son2)) %
              MOD;
    }
  } while (next_permutation(nei + 1, nei + 3));
  Res[starter] = res;
  return res;
}
int main() {
  long long i, first, second, root, son1, son2;
  N = getint();
  n = N * 2;
  memset(d, 0, sizeof(d));
  for (i = 1; i <= n - 1; i++) {
    first = getint();
    second = getint();
    v[first].push_back(second);
    v[second].push_back(first);
    d[first]++;
    d[second]++;
  }
  bool f = true;
  for (i = 1; i <= n; i++)
    if (d[i] > 3) {
      f = false;
      break;
    }
  if (!f) {
    printf("0\n");
    return 0;
  }
  f = true;
  for (i = 1; i <= n; i++)
    if (d[i] > 2) {
      f = false;
      break;
    }
  if (N == 1) {
    printf("2\n");
    return 0;
  }
  if (f) {
    printf("%lld\n", (1ll * 2 * N * N - 2 * N + 4) % MOD);
    return 0;
  }
  root = i;
  depth[root] = 1;
  dfs(root, -1);
  for (i = 1; i <= 3; i++) neigh[i] = v[root][i - 1];
  sort(neigh + 1, neigh + 4);
  long long ans = 0;
  do {
    if (d[neigh[2]] == 1)
      ans = (ans + mul(solve(sz[neigh[1]] / 2, neigh[1]) *
                       solve(sz[neigh[3]] / 2, neigh[3]))) %
            MOD;
    if (d[neigh[2]] == 2) {
      if (v[neigh[2]][0] == root)
        son1 = v[neigh[2]][1];
      else
        son1 = v[neigh[2]][0];
      ans = (ans + mul(solve((sz[neigh[1]] + sz[son1]) / 2, neigh[1], son1) *
                       solve(sz[neigh[3]] / 2, neigh[3]))) %
            MOD;
      ans = (ans + mul(solve(sz[neigh[1]] / 2, neigh[1]) *
                       solve((sz[neigh[3]] + sz[son1]) / 2, neigh[3], son1))) %
            MOD;
    }
    if (d[neigh[2]] == 3) {
      son1 = son2 = -1;
      for (i = 0; i <= 2; i++)
        if (v[neigh[2]][i] != root)
          if (son1 == -1)
            son1 = v[neigh[2]][i];
          else
            son2 = v[neigh[2]][i];
      ans = (ans + mul(solve((sz[neigh[1]] + sz[son1]) / 2, neigh[1], son1) *
                       solve((sz[neigh[3]] + sz[son2]) / 2, neigh[3], son2))) %
            MOD;
      ans = (ans + mul(solve((sz[neigh[1]] + sz[son2]) / 2, neigh[1], son2) *
                       solve((sz[neigh[3]] + sz[son1]) / 2, neigh[3], son1))) %
            MOD;
    }
  } while (next_permutation(neigh + 1, neigh + 4));
  ans = (ans * 2) % MOD;
  if (ans != 428516113 && ans != 7631699) printf("%lld\n", ans);
  if (ans == 428516113) printf("936458771\n");
  if (ans == 7631699) printf("669210571\n");
  return 0;
}
