package main

import (
  "bufio"
  "os"
  "strconv"
  "strings"
  "fmt"
  "math"
  "sort"
)

var reader = bufio.NewReaderSize(os.Stdin, 1000000)
var writer = bufio.NewWriter(os.Stdout)
func NextLine() string {
  buffer := make([]byte, 0)
  for true {
    line, isPrefix, err := reader.ReadLine()
    if err != nil { panic(err) }
    buffer = append(buffer, line...)
    if !isPrefix { break }
  }
  return string(buffer)
}
func NextInt() int {
  n, _ := strconv.Atoi(NextLine())
  return n
}
func NextIntVec() []int {
  L := strings.Split(NextLine(), " ")
  N := make([]int, len(L))
  for i := range N {
    N[i], _ = strconv.Atoi(L[i])
  }
  return N
}
func NextFloat() float64 {
  n, _ := strconv.ParseFloat(NextLine(), 64)
  return n
}
func NextFloatVec() []float64 {
  L := strings.Split(NextLine(), " ")
  N := make([]float64, len(L))
  for i := range N {
    N[i], _ = strconv.ParseFloat(L[i], 64)
  }
  return N
}
func Write(s interface{}) {
  fmt.Fprintln(writer, s)
}
func WriteIntVec(A []int) {
  S := make([]string, len(A))
  for i, a := range A {
    S[i] = strconv.Itoa(a)
  }
  Write(strings.Join(S, " "))
}
func Output() {
  _ = writer.Flush()
}

func MaxInt(A ...int) int {
  max := A[0]
  for _, a := range A {
    if max < a { max = a }
  }
  return max
}
func MinInt(A ...int) int {
  min := A[0]
  for _, a := range A {
    if a < min { min = a }
  }
  return min
}

func Dist(mode int, A ...*[]float64) float64 {
  if len(A) < 1 { return 0.0 }
  if len(A) < 2 { A = append(A, &[]float64{0.0, 0.0}) }
  D := 0.0
  for i := range (*A[0]) {
    x := (*A[0])[i] - (*A[1])[i]
    D += x * x
  }
  if mode == 1 { D = math.Sqrt(D) }
  return D
}
func InnerProduct(A, B *[]float64) float64 {
  IP := 0.0
  for i, a := range (*A) {
    IP += a * (*B)[i]
  }
  return IP
}
func Angle(A ...*[]float64) float64 {
  if len(A) < 2 { return 0.0 }
  if len(A) < 3 {
    a := make([]float64, len((*A[0])))
    A = append(A, &a)
  }
  _A := make([]float64, len((*A[0])))
  _B := make([]float64, len((*A[0])))
  for i := range (*A[0]) {
    _A[i] = (*A[0])[i] - (*A[2])[i]
    _B[i] = (*A[1])[i] - (*A[2])[i]
  }
  acos := math.Acos(InnerProduct(&_A, &_B) / Dist(1, &_A) / Dist(1, &_B))
  theta := acos / math.Pi * 180.0
  _A_ := []float64{-_A[1], _A[0]}
  if InnerProduct(&_A_, &_B) < 0 { theta = 360 - theta }
  return theta
}
func TriangleArea(mode int, A ...*[]float64) float64 {
  if len(A) < 2 { return 0.0 }
  if len(A) < 3 {
    _A := make([]*[]float64, 0)
    a := make([]float64, len((*A[0])))
    _A = append(_A, &a)
    A = append(_A, A...)
  }
  AB := []float64{(*A[1])[0] - (*A[0])[0], (*A[1])[1] - (*A[0])[1]}
  AC := []float64{(*A[2])[0] - (*A[0])[0], (*A[2])[1] - (*A[0])[1]}
  S := math.Abs(AB[0] * AC[1] - AB[1] * AC[0])
  if mode == 1 { S /= 2.0 }
  return S
}
func OuterCircle(A, B, C *[]float64) (X, Y, R float64) {
  AB := []float64{(*B)[0] - (*A)[0], (*B)[1] - (*A)[1]}
  AC := []float64{(*C)[0] - (*A)[0], (*C)[1] - (*A)[1]}
  AB2 := Dist(2, &AB)
  AC2 := Dist(2, &AC)
  IP := InnerProduct(&AB, &AC)
  b := AC2 * (IP - AB2) / (2 * (IP * IP - AB2 * AC2))
  c := AB2 * (IP - AC2) / (2 * (IP * IP - AB2 * AC2))
  X = (*A)[0] + AB[0] * b + AC[0] * c
  Y = (*A)[1] + AB[1] * b + AC[1] * c
  S := TriangleArea(1, A, B, C)
  ab := math.Sqrt(AB2)
  bc := Dist(1, B, C)
  ca := math.Sqrt(AC2)
  R = ab * bc * ca / (4 * S)
  return
}
func Less(A *[][]float64, i, j int) bool {
  if (*A)[i][0] == (*A)[j][0] { return (*A)[i][1] < (*A)[j][1] }
  return (*A)[i][0] < (*A)[j][0]
}
func GiftWrapping(A *[][]float64) []int {
  C := make([]int, 0)
  h := 0
  for i := range (*A) {
    if Less(A, h, i) { h = i }
  }
  next := h
  for len(C) == 0 || next != h {
    C = append(C, next)
    p := (*A)[next]
    for i, a := range (*A) {
      if i == next { continue }
      _A := []float64{a[0] - p[0], a[1] - p[1]}
      D1 := Dist(2, &a, &p)
      convex := true
      for j, b := range (*A) {
        if j == next || j == i { continue }
        _B := []float64{b[0] - p[0], b[1] - p[1]}
        D2 := Dist(2, &b, &p)
        OP := _A[0] * _B[1] - _A[1] * _B[0]
        if math.Abs(OP) < 1e-5 {
          if D2 < D1 { continue }
        } else if OP < 0.0 {
          continue
        }
        convex = false
        break
      }
      if !convex { continue }
      next = i
      break
    }
  }
  return C
}
type Axis [][]float64
func (A Axis) Len() int { return len(A) }
func (A Axis) Less(i, j int) bool { return A[i][2] < A[j][2] }
func (A Axis) Swap(i, j int) { A[i], A[j] = A[j], A[i] }
func GrahamScan(A *[][]float64) []int {
  N := len((*A))
  C := make([]int, 0)
  if N < 3 {
    for i := 0; i < N; i++ {
      C = append(C, i)
    }
    return C
  }
  h := 0
  for i := range (*A) {
    if ((*A)[h][0] < (*A)[i][0]) || ((*A)[h][0] == (*A)[i][0] && (*A)[h][1] < (*A)[i][1]) { h = i }
  }
  G := []float64{0.0, 0.0}
  for _, a := range (*A) {
    for i := range a { G[i] += a[i] / float64(N) }
  }
  G1 := []float64{G[0] + 1, G[1]}
  B := make([][]float64, 0)
  for i := range (*A) {
    if Dist(1, &(*A)[i], &G) < 1e-5 { continue }
    b := make([]float64, 0)
    b = append(b, (*A)[i]...)
    b = append(b, Angle(&G1, &(*A)[i], &G), float64(i))
    B = append(B, b)
  }
  sort.Sort(Axis(B))
  s := 0
  for i, b := range B {
    if int(b[3]) == h { s = i }
  }
  B = append(B[s:], B...)
  C = append(C, int(B[1][3]))
  C = append(C, int(B[0][3]))
  for _, b := range B[2:] {
    add := true
    for 1 < len(C) {
      a, c := (*A)[C[0]], (*A)[C[1]]
      ab := []float64{b[0] - a[0], b[1] - a[1]}
      ac := []float64{c[0] - a[0], c[1] - a[1]}
      OP := ab[0] * ac[1] - ab[1] * ac[0]
      if math.Abs(OP) < 1e-5 {
        if Dist(1, &c, &a) < Dist(1, &c, &b) {
          C = C[1:]
        } else {
          add = false
          break
        }
      } else if OP < 0 {
        C = C[1:]
      } else {
        break
      }
    }
    if int(b[3]) == h { break }
    if !add { continue }
    C = append(C[:1], C...)
    C[0] = int(b[3])
  }
  return C
}

func Solve() {
  N := NextInt()
  A := make([][]float64, N)
  for i := range A {
    A[i] = NextFloatVec()
  }
  C := GrahamScan(&A)
  C = append(C, C...)
  R := make([]float64, N)
  for i := 0; i < len(C) / 2; i++ {
    if C[i] == C[i + 2] {
      R[C[i + 1]] = 180.0
      continue
    }
    x, y, _ := OuterCircle(&A[C[i]], &A[C[i + 1]], &A[C[i + 2]])
    _A := []float64{(A[C[i + 2]][0] + A[C[i + 1]][0]) / 2.0, (A[C[i + 2]][1] + A[C[i + 1]][1]) / 2.0}
    _B := []float64{(A[C[i]][0] + A[C[i + 1]][0]) / 2.0, (A[C[i]][1] + A[C[i + 1]][1]) / 2.0}
    theta := Angle(&_A, &_B, &[]float64{x, y})
    if 180.0 < theta { theta -= 180.0 }
    R[C[i + 1]] = theta
  }
  for _, r := range R {
    Write(r / 360.0)
  }
  return
}

func main() {
  Solve()
  Output()
}

Measured memory_bytes: 896