#[allow(unused_imports)]
use std::cmp::*;
#[allow(unused_imports)]
use std::collections::*;

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}

fn main() {
    let n = read::<usize>();
    let mut points = Vec::new();
    for i in 0..n {
        let v = read_vec::<i64>();
        points.push(Vector2D(v[0] as f64, v[1] as f64));
    }

    let hull = convex_hull(&points);
    if hull.len() == 2 {
        for i in 0..n {
            if let Some(_) = hull.iter().find(|&&x| x == i) {
                println!("0.5");
            } else {
                println!("0.0");
            }
        }
        return;
    }
    let mut rates = vec![0f64; n];
    for (i, &middle_idx) in hull.iter().enumerate() {
        let left_idx = hull[(hull.len() + i - 1) % hull.len()];
        let right_idx = hull[(i + 1) % hull.len()];
        let theta1 = (points[right_idx].1 - points[middle_idx].1)
            .atan2(points[right_idx].0 - points[middle_idx].0)
            .to_degrees();
        let theta2 = (points[left_idx].1 - points[middle_idx].1)
            .atan2(points[left_idx].0 - points[middle_idx].0)
            .to_degrees();
        let mut angle_diff = (theta2 - theta1).abs();
        if angle_diff > 180.0 {
            angle_diff = angle_diff - 180.0;
        } else {
            angle_diff = 180.0 - angle_diff;
        }
        rates[middle_idx] = angle_diff / 360.0;
    }
    for rate in rates.into_iter() {
        println!("{:?}", rate);
    }
}

#[derive(Debug, Clone, Copy, PartialEq)]
#[allow(dead_code)]
pub struct Vector2D(f64, f64);

impl Vector2D {
    pub fn add(a: f64, b: f64) -> f64 {
        let c = a + b;
        if c.abs() < 1e-10 {
            0.0
        } else {
            c
        }
    }

    pub fn det(self, other: Vector2D) -> f64 {
        Self::add(self.0 * other.1, -self.1 * other.0)
    }
}

impl std::ops::Add for Vector2D {
    type Output = Vector2D;

    fn add(self, rhs: Vector2D) -> Self::Output {
        Vector2D(Vector2D::add(self.0, rhs.0), Vector2D::add(self.1, rhs.1))
    }
}

impl std::ops::Sub for Vector2D {
    type Output = Vector2D;

    fn sub(self, rhs: Vector2D) -> Self::Output {
        Vector2D(Vector2D::add(self.0, -rhs.0), Vector2D::add(self.1, -rhs.1))
    }
}

#[derive(PartialEq, PartialOrd)]
pub struct Total<T>(pub T);
impl<T: PartialEq> Eq for Total<T> {}

impl<T: PartialOrd> Ord for Total<T> {
    fn cmp(&self, other: &Total<T>) -> Ordering {
        self.0.partial_cmp(&other.0).unwrap()
    }
}

#[allow(dead_code)]
fn convex_hull(vs: &[Vector2D]) -> Vec<usize> {
    let mut idx: Vec<usize> = (0..vs.len()).collect();
    idx.sort_by_key(|&i| Total((vs[i].0, vs[i].1)));

    let mut res = Vec::new();

    for &i in &idx {
        while res.len() > 1
            && Vector2D::det(
                vs[res[res.len() - 1]] - vs[res[res.len() - 2]],
                vs[i] - vs[res[res.len() - 1]],
            ) <= 0.0
        {
            res.pop();
        }
        res.push(i);
    }
    let t = res.len();

    for &i in idx.iter().rev().skip(1) {
        while res.len() > t
            && (vs[res[res.len() - 1]] - vs[res[res.len() - 2]]).det(vs[i] - vs[res[res.len() - 1]])
                <= 0.0
        {
            res.pop();
        }
        res.push(i);
    }

    res.pop();
    res
}


Measured memory_bytes: 4352