#include <bits/stdc++.h>
using namespace std;
const int MAXN = 60;
inline int Read() {
  int x = 0, f = 0;
  char c = getchar();
  while (!isdigit(c)) {
    f |= c == '-';
    c = getchar();
  }
  while (isdigit(c)) {
    x = (x << 1) + (x << 3) + (c ^ 48);
    c = getchar();
  }
  return f ? -x : x;
}
inline void Write(const int &x) {
  if (x < 0) {
    putchar('-');
    Write(-x);
    return;
  }
  if (x > 9) {
    Write(x / 10);
  }
  putchar((x % 10) ^ 48);
  return;
}
vector<int> Tree[MAXN];
int n, From, To, Size[MAXN];
double DP[MAXN][MAXN], Fact[MAXN], Arr[2][MAXN];
inline double C(int n, int m) {
  return n < m ? 0 : Fact[n] / Fact[m] / Fact[n - m];
}
inline void Search(const int &Index, const int &Father) {
  Size[Index] = DP[Index][0] = 1;
  for (register int i = 0, j, k, Child; i ^ Tree[Index].size(); ++i) {
    Child = Tree[Index][i];
    if (Child ^ Father) {
      Search(Child, Index);
      for (j = 0; j <= Size[Child]; ++j) {
        Arr[0][j] = (Size[Child] - j) * DP[Child][j];
        for (k = 0; k ^ j; ++k) {
          Arr[0][j] += 0.5 * DP[Child][k];
        }
      }
      for (j = 0; j <= Size[Index] + Size[Child]; ++j) {
        Arr[1][j] = 0;
      }
      for (j = 0; j ^ Size[Index]; ++j) {
        for (k = 0; k <= Size[Child]; ++k) {
          Arr[1][j + k] +=
              DP[Index][j] * Arr[0][k] *
              C(Size[Index] + Size[Child] - j - k - 1, Size[Index] - j - 1) *
              C(j + k, j);
        }
      }
      Size[Index] += Size[Child];
      for (j = 0; j ^ Size[Index]; ++j) {
        DP[Index][j] = Arr[1][j];
      }
    }
  }
  return;
}
signed main() {
  register int i;
  n = Read(), Fact[0] = 1;
  for (i = 1; i ^ n; ++i) {
    From = Read(), To = Read();
    Tree[From].push_back(To);
    Tree[To].push_back(From);
  }
  for (i = 1; i <= n; ++i) {
    Fact[i] = Fact[i - 1] * i;
  }
  for (i = 1; i <= n; ++i) {
    memset(DP, 0, sizeof DP);
    Search(i, 0), printf("%.10f\n", DP[i][n - 1] / Fact[n - 1]);
  }
  return 0;
}
