#include <bits/stdc++.h>
enum kind { white, black, grey };
struct Edge {
  int ID;
  Edge *next;
};
struct Node {
  Edge *first;
  kind color;
  double possibility[51];
  int childnumber;
  int edge;
  double po;
};
int min(int x, int y) {
  if (x >= y)
    return y;
  else
    return x;
}
int max(int x, int y) {
  if (x >= y)
    return x;
  else
    return y;
}
double c[51][51], result[51][51], use[51], temporary[51];
void merge(double *x, double *y, double *z, int xedge, int yedge) {
  int i, j;
  for (i = 0; i <= 50; i++) z[i] = 0;
  for (i = 0; i <= xedge + yedge; i++)
    for (j = max(0, i - yedge); j <= min(i, xedge); j++)
      z[i] += x[j] * y[i - j] * c[i][j] * c[xedge + yedge - i][xedge - j] /
              c[xedge + yedge][xedge];
}
void generate(double *x, double *y, int xedge) {
  int i, j;
  for (i = 0; i <= xedge + 1; i++) {
    if ((i != 0) && (i != xedge + 1)) {
      y[i] = x[i - 1] * i / (xedge + 1);
      for (j = i + 1; j <= xedge + 1; j++) y[i] += 0.5 * x[j - 1] / (xedge + 1);
    } else if (i == 0) {
      y[0] = 0;
      for (j = 1; j <= xedge + 1; j++) y[0] += 0.5 * x[j - 1] / (xedge + 1);
    } else
      y[xedge + 1] = x[xedge];
  }
}
void DFS(int n, Node *x) {
  int u = 0, i, toledge = 0;
  x[n].color = grey;
  x[n].edge = 0;
  Edge *y = x[n].first;
  if (x[n].childnumber == 0)
    x[n].possibility[0] = 1;
  else {
    while (y != NULL) {
      if (x[y->ID].color == white) {
        DFS(y->ID, x);
        x[n].edge += x[y->ID].edge + 1;
        u++;
        generate(x[y->ID].possibility, use, x[y->ID].edge);
        if (u == 1) {
          for (i = 0; i <= x[y->ID].edge + 1; i++) result[n][i] = use[i];
          toledge = x[y->ID].edge + 1;
        } else {
          for (i = 0; i <= toledge; i++) temporary[i] = result[n][i];
          merge(temporary, use, result[n], toledge, x[y->ID].edge + 1);
          toledge += x[y->ID].edge + 1;
        }
      }
      y = y->next;
    }
    for (i = 0; i <= toledge; i++) x[n].possibility[i] = result[n][i];
  }
  x[n].color = black;
}
void DFS2(int n, Node *x) {
  int i, toledge;
  double originfather[51], originchild[51];
  x[n].po = x[n].possibility[0];
  x[n].color = grey;
  Edge *y = x[n].first, *z;
  for (i = 0; i <= x[n].edge; i++) originfather[i] = x[n].possibility[i];
  while (y != NULL) {
    if (x[y->ID].color == white) {
      for (i = 0; i <= x[y->ID].edge; i++)
        originchild[i] = x[y->ID].possibility[i];
      toledge = 0;
      z = x[n].first;
      while (z != NULL) {
        if (z->ID != y->ID) {
          generate(x[z->ID].possibility, use, x[z->ID].edge);
          if (toledge == 0)
            for (i = 0; i <= x[z->ID].edge + 1; i++) result[n][i] = use[i];
          else {
            for (i = 0; i <= toledge; i++) temporary[i] = result[n][i];
            merge(temporary, use, result[n], toledge, x[z->ID].edge + 1);
          }
          toledge += x[z->ID].edge + 1;
        }
        z = z->next;
      }
      for (i = 0; i <= toledge; i++) x[n].possibility[i] = result[n][i];
      x[n].edge = toledge;
      generate(x[n].possibility, use, toledge);
      merge(x[y->ID].possibility, use, temporary, x[y->ID].edge, toledge + 1);
      x[y->ID].edge += toledge + 1;
      for (i = 0; i <= x[y->ID].edge; i++)
        x[y->ID].possibility[i] = temporary[i];
      DFS2(y->ID, x);
      x[y->ID].edge = x[y->ID].edge - toledge - 1;
      x[n].edge = toledge + 1 + x[y->ID].edge;
      for (i = 0; i <= x[n].edge; i++) x[n].possibility[i] = originfather[i];
      for (i = 0; i <= x[y->ID].edge; i++)
        x[y->ID].possibility[i] = originchild[i];
    }
    y = y->next;
  }
  x[n].color = black;
}
double C(int i, int j) {
  int x;
  double y = 1, z = 1, result;
  for (x = 1; x <= j; x++) y = y * double(x);
  for (x = i - j + 1; x <= i; x++) z = z * double(x);
  return z / y;
}
int main() {
  using namespace std;
  cout.precision(11);
  cout.setf(ios_base::showpoint);
  int n, i, u, v, j;
  cin >> n;
  Node x[52];
  Edge *y, *z;
  for (i = 0; i <= 50; i++)
    for (j = 0; j <= i; j++) c[i][j] = C(i, j);
  for (i = 1; i <= n; i++) {
    x[i].first = NULL;
    x[i].childnumber = -1;
    x[i].edge = 0;
  }
  for (i = 1; i <= n - 1; i++) {
    cin >> u >> v;
    y = new Edge;
    y->ID = v;
    y->next = NULL;
    if (x[u].first == NULL)
      x[u].first = y;
    else {
      y->next = x[u].first;
      x[u].first = y;
    }
    y = new Edge;
    y->ID = u;
    y->next = NULL;
    if (x[v].first == NULL)
      x[v].first = y;
    else {
      y->next = x[v].first;
      x[v].first = y;
    }
    x[u].childnumber++;
    x[v].childnumber++;
  }
  for (i = 1; i <= n; i++) x[i].color = white;
  x[1].childnumber++;
  DFS(1, x);
  x[1].childnumber--;
  x[1].po = x[1].possibility[0];
  for (j = 2; j <= n; j++) {
    for (i = 1; i <= n; i++) x[i].color = white;
    x[j].childnumber++;
    DFS(j, x);
    x[j].childnumber--;
    x[j].po = x[j].possibility[0];
  }
  for (i = 1; i <= n; i++) cout << x[i].po << endl;
  for (i = 1; i <= n; i++) {
    y = x[i].first;
    while (y != NULL) {
      z = y->next;
      free(y);
      y = z;
    }
  }
  cin >> n;
  return 0;
}
