```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"slices"
)

type Contract struct {
	x, w, c int64
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n int
	var numCustomers int64
	fmt.Fscan(reader, &n, &numCustomers)

	contracts := make([]Contract, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(reader, &contracts[i].x, &contracts[i].w, &contracts[i].c)
	}

	slices.SortFunc(contracts, func(a, b Contract) int {
		if a.x != b.x {
			if a.x < b.x {
				return -1
			}
			return 1
		}
		if a.c != b.c {
			if a.c > b.c {
				return -1
			}
			return 1
		}
		if a.w != b.w {
			if a.w < b.w {
				return -1
			}
			return 1
		}
		return 0
	})

	dp := make([][]int64, n)
	for i := 0; i < n; i++ {
		dp[i] = make([]int64, n-i)
		for j := 0; j < n-i; j++ {
			dp[i][j] = -2000000000000000000
		}
	}

	var ans int64 = 0

	Sin := make([]int, 0, n)
	Sout := make([]int, 0, n)

	for j := 0; j < n; j++ {
		Sin = Sin[:0]
		for k := 0; k < j; k++ {
			if contracts[k].x < contracts[j].x {
				Sin = append(Sin, k)
			}
		}

		Sout = Sout[:0]
		for i := j + 1; i < n; i++ {
			if contracts[i].x > contracts[j].x {
				Sout = append(Sout, i)
			}
		}

		slices.SortFunc(Sin, func(k1, k2 int) int {
			left := (contracts[j].c - contracts[k1].c) * (contracts[j].x - contracts[k2].x)
			right := (contracts[j].c - contracts[k2].c) * (contracts[j].x - contracts[k1].x)
			if left > right {
				return -1
			}
			if left < right {
				return 1
			}
			return 0
		})

		slices.SortFunc(Sout, func(i1, i2 int) int {
			left := (contracts[i1].c - contracts[j].c) * (contracts[i2].x - contracts[j].x)
			right := (contracts[i2].c - contracts[j].c) * (contracts[i1].x - contracts[j].x)
			if left > right {
				return -1
			}
			if left < right {
				return 1
			}
			return 0
		})

		maxDp := -contracts[j].w * 200
		ptr := 0

		for _, i := range Sout {
			for ptr < len(Sin) {
				k := Sin[ptr]
				left := (contracts[j].c - contracts[k].c) * (contracts[i].x - contracts[j].x)
				right := (contracts[i].c - contracts[j].c) * (contracts[j].x - contracts[k].x)
				if left > right {
					if dp[k][j-k] > maxDp {
						maxDp = dp[k][j-k]
					}
					ptr++
				} else {
					break
				}
			}
			cost := numCustomers * (contracts[j].c + contracts[i].c) * (contracts[i].x - contracts[j].x)
			val := maxDp + cost - contracts[i].w*200
			dp[j][i-j] = val
			if val > ans {
				ans = val
			}
		}
	}

	fmt.Printf("%.15f\n", float64(ans)/200.0)
}
```