```go
package main

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

type Interval struct {
	L, R float64
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n int
	if _, err := fmt.Fscan(reader, &n); err != nil {
		return
	}

	xl := make([]int, n)
	xr := make([]int, n)
	y := make([]int, n)

	for i := 0; i < n; i++ {
		fmt.Fscan(reader, &xl[i], &xr[i], &y[i])
	}

	intervals := make([]Interval, 0, n*(n-1)/2)
	for i := 0; i < n; i++ {
		for j := 0; j < n; j++ {
			if y[i] > y[j] {
				L := float64(xl[j]-xr[i]) / float64(y[i]-y[j])
				R := float64(xr[j]-xl[i]) / float64(y[i]-y[j])
				intervals = append(intervals, Interval{L, R})
			}
		}
	}

	sort.Slice(intervals, func(i, j int) bool {
		if intervals[i].L != intervals[j].L {
			return intervals[i].L < intervals[j].L
		}
		return intervals[i].R < intervals[j].R
	})

	merged := make([]Interval, 0)
	if len(intervals) > 0 {
		curr := intervals[0]
		for i := 1; i < len(intervals); i++ {
			iv := intervals[i]
			if iv.L < curr.R {
				if iv.R > curr.R {
					curr.R = iv.R
				}
			} else {
				merged = append(merged, curr)
				curr = iv
			}
		}
		merged = append(merged, curr)
	}

	S := func(c float64) float64 {
		minL := math.MaxFloat64
		maxR := -math.MaxFloat64
		for i := 0; i < n; i++ {
			left := float64(xl[i]) + float64(y[i])*c
			right := float64(xr[i]) + float64(y[i])*c
			if left < minL {
				minL = left
			}
			if right > maxR {
				maxR = right
			}
		}
		return maxR - minL
	}

	l := -3e6
	r := 3e6
	for iter := 0; iter < 150; iter++ {
		m1 := l + (r-l)/3
		m2 := r - (r-l)/3
		if S(m1) < S(m2) {
			r = m2
		} else {
			l = m1
		}
	}
	c_star := l + (r-l)/2

	minVal := S(c_star)

	l_bin, r_bin := 0, len(merged)-1
	for l_bin <= r_bin {
		mid := l_bin + (r_bin-l_bin)/2
		if c_star > merged[mid].L && c_star < merged[mid].R {
			val1 := S(merged[mid].L)
			val2 := S(merged[mid].R)
			if val1 < val2 {
				minVal = val1
			} else {
				minVal = val2
			}
			break
		} else if c_star <= merged[mid].L {
			r_bin = mid - 1
		} else {
			l_bin = mid + 1
		}
	}

	fmt.Printf("%.9f\n", minVal)
}
```