#include <bits/stdc++.h>

 

#define pb push_back

#define mp make_pair

#define fs first

#define sc second

#define rep(i, from, to) for (int i = from; i < (to); ++i)

#define all(x) x.begin(), x.end()

#define sz(x) (int) (x).size()

#define FOR(i, to) for (int i = 0; i < (to); ++i)

 

using namespace std;

typedef long long ll;

typedef vector<int> vi;

typedef pair<int,int> pii;

typedef pair<double,double> pdd;

typedef vector<ll> vll;

typedef vector<pair<int,int>> vpi;

typedef pair<ll,ll> pll;

typedef vector<string> vs;

#define MOD 998244353

#define mod 998244353

#define INF 1000000000LL * 100000000LL

#define Nmax 2020200

int N, T, M, K, Q;

ll X;
ll sum;
ll sm = 0;
#define PI 3.141592653589793
#define eps 0.00000001
int cmp(double a, double b) {
  if(a + eps <= b) return -1; if(a < b + eps) return 0; return 1;
}
int cmp(pdd a, pdd b) {
  int t = cmp(a.fs, b.fs); if(t) return t; return cmp(a.sc,b.sc);
}
pdd in = mp(INFINITY, INFINITY); //no solution
pdd operator+(pdd a, pdd b) { return mp(a.fs+b.fs, a.sc+b.sc); }
pdd operator-(pdd a, pdd b) { return mp(a.fs-b.fs, a.sc-b.sc); }
pdd operator*(pdd a, double t) { return mp(a.fs*t, a.sc*t); }
pdd operator/(pdd a, double t) { return mp(a.fs/t, a.sc/t); }
double operator*(pdd a, pdd b) { return a.fs*b.fs + a.sc*b.sc; }
double operator%(pdd a, pdd b) { return a.fs*b.sc - a.sc*b.fs; }
bool operator<(pdd a, pdd b) { return cmp(a,b) < 0; }
bool operator==(pdd a, pdd b) { return cmp(a,b) == 0; }
double norm(pdd a) { return sqrt(a*a); }
double arg(pdd a) { return atan2(a.sc,a.fs); }
inline double dist(pdd p, pdd q) { return norm(p-q);}
inline int ccw(pdd a, pdd b, pdd c) { return cmp((a-c)%(b-c),0);}

inline double angle(pdd a, pdd b, pdd c) { //[-PI/2, PI/2]
  pdd u = a - b, v = c - b; double r = atan2(u % v, u * v);
  if(r < 0) r += PI;
  return r;
}
inline int between(pdd p, pdd q, pdd r) {
  return ccw(p,q,r) == 0 && cmp((p-q)*(r-q),0) <= 0;
}

vector<pdd> hull2 (vector<pdd> & a) {
  if (a.size() == 1)  return a;
  sort (a.begin(), a.end()); pdd p1 = a[0],  p2 = a.back();
  vector<pdd> up, down, b; up.pb (p1); down.pb (p1);
  for (int i=1; i<a.size(); ++i) {
    if (i==a.size()-1 || ccw (p1, a[i], p2) < 0) { //<= > for colin
      while (up.size()>=2 && ccw(up[up.size()-2], up[up.size()-1], a[i]) >= 0) {
        up.pop_back(); }
      up.pb(a[i]);
    }
    if(i==a.size()-1 || ccw (p1, a[i], p2) > 0) { //>= < for colin
      while (down.size()>=2 && ccw(down[down.size()-2], down[down.size()-1], a[i]) <= 0) {
        down.pop_back();
      }
      down.pb (a[i]);
    }
  }
  for (size_t i=0; i<down.size(); ++i) b.pb(down[i]);
  for (size_t i=up.size()-2; i>0; --i) b.pb(up[i]);
  return b;
}

vector<pdd> v,vx;
map<pdd,double> h;

int main() {

  cin.sync_with_stdio(false);

  cin >> N;
  FOR(i, N) {
    double x,y;
    cin >> x >> y;
    v.pb(mp(x,y));
    vx.pb(mp(x,y));
  }
  v = hull2(v);
  if(sz(v) == 2) {
    FOR(i, sz(v)) {
      h[v[i]] = 0.5;
    }
  } else {
    for(int i=0;i<sz(v);++i) {
      int nx1 = (i-1 + sz(v)) % sz(v);
      int nx2 = (i+1 + sz(v)) % sz(v);

      h[v[i]] = (angle(v[nx1], v[i], v[nx2])) / (2 * PI);
    }
  }
  double vl = 0;
  std::cout << std::fixed;
  std::cout << std::setprecision(9);

  FOR(i, N) {
    cout << h[vx[i]] << "\n";
    vl += h[vx[i]];
  }
  

}

 

Measured memory_bytes: 256