#include <bits/stdc++.h>
using namespace std;
const int C = 101;
vector<vector<int> > tr(C);
int ij[C];
int s[C], is = 0, ip = 1, pre[C], apre[C], dep[C], sons[C], par[C], ji[C];
void proc_tree(int a, int n, vector<vector<int> > &tab, int ij[]) {
  s[0] = a, is = 1, pre[a] = 1, apre[1] = a, dep[a] = 1, ip = 2;
  int b;
  for (int z = 1; z <= n; z++) ji[z] = ij[z], par[z] = 0, sons[z] = 0;
  while (is > 0) {
    a = s[is - 1];
    if (ji[a] > 0 && tab[a][ji[a] - 1] == par[a]) ji[a]--;
    if (ji[a] > 0)
      b = s[is] = tab[a][ji[a] - 1], pre[b] = ip, apre[ip] = b, par[b] = a,
      dep[b] = is + 1, ip++, is++, ji[a]--;
    else
      sons[a]++, sons[par[a]] += sons[a], is--;
  }
}
long double cn[C][C];
void binominalization(int n) {
  int i, j;
  cn[0][0] = 1;
  for (i = 1; i < n; i++) {
    for (j = 0; j < n; j++)
      cn[i][j] = cn[i - 1][j] + ((j == 0) ? 0 : cn[i - 1][j - 1]);
  }
}
int processed[C];
long double dp[C][C][C], csc[C][C][C], tmp[2][C][C], pw[C], summa[C], summa0[C],
    summa1[C];
int main() {
  int n, a, b, para;
  int i, j, iij, k, elem, root, lj, lk;
  long double prob, res = 0, full = 0;
  scanf("%d", &n);
  for (int z = 1; z < n; z++)
    scanf("%d %d", &a, &b), tr[a].push_back(b), tr[b].push_back(a), ij[a]++,
        ij[b]++;
  binominalization(C);
  pw[0] = 1;
  for (i = 1; i <= n; i++) pw[i] = pw[i - 1] / 2;
  for (root = 1; root <= n; root++) {
    proc_tree(root, n, tr, ij);
    for (elem = n; elem > 0; elem--) {
      a = apre[elem];
      dp[a][0][0] = 1;
      for (iij = 0; iij < ij[a]; iij++) {
        b = tr[a][iij];
        if (par[a] == b) continue;
        for (j = 0; j <= sons[b] - 1; j++) {
          for (k = 0; k <= sons[b] - 1; k++) {
            prob = (1.0 * (j + 1)) / sons[b];
            tmp[0][j][k + 1] = csc[b][j][k] / sons[b];
            tmp[1][j + 1][k] = dp[b][j][k] * prob;
          }
        }
        for (j = processed[a] + sons[b]; j >= 0; j--) {
          for (k = processed[a] + sons[b]; k >= 0; k--) {
            dp[a][j][k] = 0;
            for (lj = 0; lj <= sons[b] && lj <= j; lj++) {
              for (lk = 0; lk <= sons[b] && lk <= k; lk++) {
                if (cn[processed[a] + sons[b]][j] == 0)
                  prob = 0;
                else
                  prob = ((cn[processed[a]][j - lj] * cn[sons[b]][lj]) /
                          cn[processed[a] + sons[b]][j]);
                dp[a][j][k] += dp[a][j - lj][k - lk] *
                               (tmp[0][lj][lk] + tmp[1][lj][lk]) * prob;
              }
            }
          }
        }
        processed[a] += sons[b];
        for (j = 0; j <= n; j++) {
          for (k = 0; k <= n; k++) {
            tmp[0][j][k] = 0;
            tmp[1][j][k] = 0;
          }
        }
      }
      for (j = n; j >= 0; j--) {
        for (k = n; k >= 0; k--) {
          csc[a][j][k] = csc[a][j + 1][k] + dp[a][j][k];
        }
      }
    }
    for (i = 0; i <= n; i++) res = res + dp[root][0][i] * pw[i];
    cout << res << endl;
    for (i = 0; i <= n; i++) {
      for (j = 0; j <= n; j++) {
        for (k = 0; k <= n; k++) {
          dp[i][j][k] = 0;
          csc[i][j][k] = 0;
        }
      }
      processed[i] = 0;
    }
    res = 0;
  }
  return 0;
}
