package main

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

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 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 Output() {
  _ = writer.Flush()
}

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 Convex(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
}

func Solve() {
  N := NextInt()
  A := make([][]float64, N)
  for i := range A {
    A[i] = NextFloatVec()
  }
  C := Convex(&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