package main

import (
	"bufio"
	"io"
	"math/big"
	"os"
)

func nextRand(x *uint64) uint64 {
	*x ^= *x >> 12
	*x ^= *x << 25
	*x ^= *x >> 27
	return *x * 2685821657736338717
}

func dayCost(idx []int, s, w []int64, target int64, seed *uint64) (int64, int64, int64) {
	l, r := 0, len(idx)
	var full int64
	for {
		if target == 0 || l >= r {
			return full, 0, 1
		}
		p := l + int(nextRand(seed)%uint64(r-l))
		pv := idx[p]
		pvS := s[pv]
		pvW := w[pv]

		lt, i, gt := l, l, r
		var wLess, cLess, wEq, cEq int64

		for i < gt {
			j := idx[i]
			left := s[j] * pvW
			right := pvS * w[j]
			if left < right {
				wLess += w[j]
				cLess += s[j]
				idx[lt], idx[i] = idx[i], idx[lt]
				lt++
				i++
			} else if left > right {
				gt--
				idx[i], idx[gt] = idx[gt], idx[i]
			} else {
				wEq += w[j]
				cEq += s[j]
				i++
			}
		}

		if target <= wLess {
			r = lt
		} else if target <= wLess+wEq {
			full += cLess
			rem := target - wLess
			if rem == 0 {
				return full, 0, 1
			}
			return full, rem * pvS, pvW
		} else {
			full += cLess + cEq
			target -= wLess + wEq
			l = gt
		}
	}
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	pos := 0
	nextInt := func() int64 {
		for pos < len(data) && (data[pos] < '0' || data[pos] > '9') {
			pos++
		}
		var v int64
		for pos < len(data) && data[pos] >= '0' && data[pos] <= '9' {
			v = v*10 + int64(data[pos]-'0')
			pos++
		}
		return v
	}

	n := int(nextInt())
	m := int(nextInt())
	W := nextInt()

	w := make([]int64, m)
	for i := 0; i < m; i++ {
		w[i] = nextInt()
	}

	s := make([]int64, m)
	for i := 0; i < m; i++ {
		s[i] = nextInt()
	}

	a := make([]int64, m)
	for i := 0; i < m; i++ {
		a[i] = nextInt()
	}

	idx := make([]int, m)
	var totalInt int64
	fracTotal := new(big.Rat)
	tmp := new(big.Rat)
	seed := uint64(88172645463393265)

	for day := 0; day < n; day++ {
		for i := 0; i < m; i++ {
			idx[i] = i
		}

		full, num, den := dayCost(idx, s, w, W, &seed)
		totalInt += full
		if num != 0 {
			tmp.SetFrac64(num, den)
			fracTotal.Add(fracTotal, tmp)
		}

		if day+1 < n {
			for i := 0; i < m; i++ {
				s[i] -= a[i]
			}
		}
	}

	res := new(big.Rat).SetInt64(totalInt)
	res.Add(res, fracTotal)

	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	out.WriteString(res.FloatString(12))
	out.Flush()
}