Problem: The New Year celebrations in Berland last n days. Only this year the winter is snowless, that’s why the winter celebrations’ organizers should buy artificial snow. There are m snow selling companies in Berland. Every day the i-th company produces wi cubic meters of snow. Next day the snow thaws and the company has to produce wi cubic meters of snow again. During the celebration new year discounts are on, that’s why the snow cost decreases every day. It is known that on the first day the total cost of all the snow produced by the i-th company is equal to ci bourles. Every day this total cost decreases by ai bourles, i.e. on the second day it is equal to ci - ai,and on the third day — to ci - 2ai, and so on. It is known that for one company the cost of the snow produced by it does not get negative or equal to zero. You have to organize the snow purchase so as to buy every day exactly W snow cubic meters. At that it is not necessary to buy from any company all the snow produced by it. If you buy ni cubic meters of snow (0 ≤ ni ≤ wi, the number ni is not necessarily integer!) from the i-th company at one of the days when the cost of its snow is equal to si, then its price will total to <image> bourles. During one day one can buy the snow from several companies. In different days one can buy the snow from different companies. It is required to make the purchases so as to spend as little money as possible. It is guaranteed that the snow produced by the companies will be enough.

Input

The first line contains integers n, m and W (1 ≤ n ≤ 100, 1 ≤ m ≤ 500000, 1 ≤ W ≤ 109) which represent the number of days, the number of companies and the amount of snow that needs to be purchased on every one of the n days. The second line contains m integers wi. The third line contains m integers ci. The fourth line contains m integers ai. All the numbers are strictly positive and do not exceed 109. For all the i the inequation ci - (n - 1)ai > 0 holds true. 

Output

Print a single number — the answer to the given problem. Print the answer in the format with the decimal point (even if the answer is integer, it must contain the decimal point), without "e" and without leading zeroes. The answer should differ with the right one by no more than 10 - 9.

Examples

Input

2 3 10
4 4 4
5 5 8
1 2 5


Output

22.000000000000000


Input

100 2 1000000000
999999998 999999999
1000000000 1000000000
1 1


Output

99999995149.999995249999991

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
struct firm {
  int w, c, a;
  long double cc, ca;
};
int a, b, c, d, i, j, n, m, k, w;
char str[(1 << 17) + 1], *cc = str;
long long cel;
long double dr;
inline char next_char() {
  if (*cc == 0) {
    fread(str, sizeof(char), 1 << 17, stdin);
    cc = str;
  }
  return *(cc++);
}
inline int next_int() {
  static int ans;
  static char ch;
  ans = 0;
  while ((ch = next_char()) < '0' || ch > '9')
    ;
  ans = ch - '0';
  while ((ch = next_char()) >= '0' && ch <= '9') ans = ans * 10 + ch - '0';
  return ans;
}
firm mas[500001];
inline bool cmp_c(const firm &a, const firm &b) {
  return (long long)a.c * b.w < (long long)b.c * a.w;
}
inline bool cmp_a(const firm &a, const firm &b) {
  return (long long)a.a * b.w > (long long)b.a * a.w;
}
inline bool cmp_cc(const firm &a, const firm &b) { return a.cc + 1e-9 < b.cc; }
void quick_sort(firm *l, firm *r, int w) {
  if (r <= l + 1) return;
  firm *xx = l + (r - l) / 2;
  nth_element(l, xx, r, cmp_c);
  int sum = 0;
  for (firm *it = l; it != xx; ++it) {
    sum += it->w;
    if (sum >= w) break;
  }
  if (sum >= w)
    quick_sort(l, xx, w);
  else
    quick_sort(xx, r, w - sum);
}
int main() {
  n = next_int();
  m = next_int();
  w = next_int();
  for (int _n((m)-1), i(0); i <= _n; i++) mas[i].w = next_int();
  for (int _n((m)-1), i(0); i <= _n; i++) mas[i].c = next_int();
  for (int _n((m)-1), i(0); i <= _n; i++) mas[i].a = next_int();
  sort(mas, mas + m, cmp_c);
  for (int _n((m)-1), i(0); i <= _n; i++) {
    mas[i].cc = (long double)mas[i].c / mas[i].w;
    mas[i].ca = (long double)mas[i].a / mas[i].w;
  }
  for (int _n((n)-1), h(0); h <= _n; h++) {
    int need = w;
    for (int _n((m)-1), i(0); i <= _n; i++) {
      if (need >= mas[i].w) {
        need -= mas[i].w;
        cel += mas[i].c;
        if (!need) break;
      } else {
        long long ch = (long long)mas[i].c * need;
        long long o = ch / mas[i].w;
        cel += o;
        ch -= o * mas[i].w;
        dr += (long double)ch / mas[i].w;
        break;
      }
    }
    for (int _n((m)-1), i(0); i <= _n; i++)
      mas[i].c -= mas[i].a, mas[i].cc -= mas[i].ca;
    quick_sort(mas, mas + m, w);
  }
  cel += (long long)floor(dr);
  dr -= floor(dr);
  if (dr < 0) dr += 1.0;
  sprintf(str, "%.12lf", (double)dr);
  if (str[0] == '1') ++cel;
  ostringstream oss;
  oss << cel;
  printf("%s%s\n", oss.str().c_str(), str + 1);
}