```go
package main

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

type Point struct {
	X, Y float64
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())

	P := make([]Point, n)
	for i := 0; i < n; i++ {
		scanner.Scan()
		x, _ := strconv.ParseFloat(scanner.Text(), 64)
		scanner.Scan()
		y, _ := strconv.ParseFloat(scanner.Text(), 64)
		P[i] = Point{X: x, Y: y}
	}

	Phi := make([]float64, n)
	Phi[0] = math.Atan2(P[1].Y-P[0].Y, P[1].X-P[0].X)
	for i := 1; i < n; i++ {
		j := (i + 1) % n
		angle := math.Atan2(P[j].Y-P[i].Y, P[j].X-P[i].X)
		diff := math.Mod(angle-Phi[i-1], 2*math.Pi)
		if diff <= 0 {
			diff += 2 * math.Pi
		}
		Phi[i] = Phi[i-1] + diff
	}

	N_angles := make([]float64, n+1)
	for i := 0; i < n; i++ {
		N_angles[i] = Phi[i] - math.Pi/2
	}
	N_angles[n] = N_angles[0] + 2*math.Pi

	var critical []float64
	for i := 0; i < n; i++ {
		c := math.Mod(N_angles[i], math.Pi/2)
		if c < 0 {
			c += math.Pi / 2
		}
		if c >= math.Pi/2 {
			c -= math.Pi / 2
		}
		critical = append(critical, c)
	}
	critical = append(critical, 0.0, math.Pi/2)
	sort.Float64s(critical)

	var expectedArea float64
	for i := 0; i < len(critical)-1; i++ {
		alpha := critical[i]
		beta := critical[i+1]
		if beta == alpha {
			continue
		}
		if alpha >= math.Pi/2 || beta <= 0 {
			continue
		}
		if alpha < 0 {
			alpha = 0
		}
		if beta > math.Pi/2 {
			beta = math.Pi / 2
		}

		mid := (alpha + beta) / 2

		t_idx := GetExtreme(mid, N_angles)
		r_idx := GetExtreme(mid+math.Pi/2, N_angles)
		b_idx := GetExtreme(mid+math.Pi, N_angles)
		l_idx := GetExtreme(mid+3*math.Pi/2, N_angles)

		dXw := P[t_idx].X - P[b_idx].X
		dYw := P[t_idx].Y - P[b_idx].Y

		dXh := P[r_idx].X - P[l_idx].X
		dYh := P[r_idx].Y - P[l_idx].Y

		term1 := dXw * dYh * I_cc(alpha, beta)
		term2 := -dYw * dXh * I_ss(alpha, beta)
		term3 := (dYw * dYh - dXw * dXh) * I_sc(alpha, beta)

		expectedArea += term1 + term2 + term3
	}

	expectedArea *= 2 / math.Pi
	fmt.Printf("%.9f\n", expectedArea)
}

func GetExtreme(psi float64, N_angles []float64) int {
	n := len(N_angles) - 1
	for psi < N_angles[0] {
		psi += 2 * math.Pi
	}
	for psi >= N_angles[n] {
		psi -= 2 * math.Pi
	}

	idx := sort.Search(n+1, func(i int) bool {
		return N_angles[i] > psi
	})
	ans := idx - 1
	return (ans + 1) % n
}

func I_cc(alpha, beta float64) float64 {
	return 0.5 * (beta - alpha + 0.5*(math.Sin(2*beta)-math.Sin(2*alpha)))
}

func I_ss(alpha, beta float64) float64 {
	return 0.5 * (beta - alpha - 0.5*(math.Sin(2*beta)-math.Sin(2*alpha)))
}

func I_sc(alpha, beta float64) float64 {
	return -0.25 * (math.Cos(2*beta) - math.Cos(2*alpha))
}
```