#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000 + 7;
const long long LL_INF = 1ll * INF * INF;
const int MAX_N = 50 + 7;
template <typename T>
inline void addmod(T& a, const long long& b, const int& MOD = INF) {
  a = (a + b) % MOD;
  if (a < 0) a += MOD;
}
int n;
vector<int> adj[MAX_N];
double dp[MAX_N][MAX_N];
double C[MAX_N][MAX_N];
int f[MAX_N];
void init() {
  for (int i = (0), _b = (MAX_N); i < _b; ++i) {
    C[i][0] = C[i][i] = 1;
    for (int j = (1), _b = (i); j < _b; ++j)
      C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
  }
}
void dfs(int u, int r) {
  fill_n(dp[u], MAX_N, 0);
  dp[u][0] = 1;
  f[u] = 1;
  for (int v : adj[u])
    if (v != r) {
      dfs(v, u);
      static double temp[MAX_N];
      fill_n(temp, f[v] + 1, 0);
      double rev_p = 1.0 / f[v];
      for (int k = 0; k <= f[v]; ++k) {
        if (k > 0) {
          temp[k] += k * dp[v][k - 1] * rev_p;
        }
        for (int j = k; j < f[v]; ++j) temp[k] += dp[v][j] * 0.5 * rev_p;
      }
      static double dp_temp[MAX_N];
      fill_n(dp_temp, MAX_N, 0);
      for (int i = (0), _b = (f[u]); i < _b; ++i)
        for (int j = (0), _b = (f[v] + 1); j < _b; ++j) {
          double prop = C[i + j][j] * C[f[u] - 1 + f[v] - i - j][f[v] - j] /
                        C[f[u] + f[v] - 1][f[v]];
          dp_temp[i + j] += dp[u][i] * temp[j] * prop;
        }
      f[u] += f[v];
      for (int i = (0), _b = (f[u]); i < _b; ++i) dp[u][i] = dp_temp[i];
    }
}
void solve() {
  init();
  cin >> n;
  for (int i = (1), _b = (n); i < _b; ++i) {
    int u, v;
    cin >> u >> v;
    adj[u].push_back(v);
    adj[v].push_back(u);
  }
  for (int i = (1), _b = (n + 1); i < _b; ++i) {
    dfs(i, -1);
    cout << std::fixed << std::setprecision(6) << dp[i][0] << '\n';
  }
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  const bool multiple_test = false;
  int test = 1;
  if (multiple_test) cin >> test;
  for (int i = 0; i < test; ++i) {
    solve();
  }
}
