Problem: Many of you must be familiar with the Google Code Jam round rules. Let us remind you of some key moments that are crucial to solving this problem. During the round, the participants are suggested to solve several problems, each divided into two subproblems: an easy one with small limits (Small input), and a hard one with large limits (Large input). You can submit a solution for Large input only after you've solved the Small input for this problem. There are no other restrictions on the order of solving inputs. In particular, the participant can first solve the Small input, then switch to another problem, and then return to the Large input. Solving each input gives the participant some number of points (usually different for each problem). This takes into account only complete solutions that work correctly on all tests of the input. The participant gets the test result of a Small input right after he submits it, but the test result of a Large input are out only after the round's over. In the final results table the participants are sorted by non-increasing of received points. If the points are equal, the participants are sorted by ascending of time penalty. By the Google Code Jam rules the time penalty is the time when the last correct solution was submitted.

Vasya decided to check out a new tactics on another round. As soon as the round begins, the boy quickly read all the problems and accurately evaluated the time it takes to solve them. Specifically, for each one of the n problems Vasya knows five values:

  * Solving the Small input of the i-th problem gives to the participant scoreSmalli points, and solving the Large input gives scoreLargei more points. That is, the maximum number of points you can get for the i-th problem equals scoreSmalli + scoreLargei.
  * Writing the solution for the Small input of the i-th problem takes exactly timeSmalli minutes for Vasya. Improving this code and turning it into the solution of the Large input takes another timeLargei minutes.
  * Vasya's had much practice, so he solves all Small inputs from the first attempt. But it's not so easy with the Large input: there is the probFaili probability that the solution to the Large input will turn out to be wrong at the end of the round. Please keep in mind that these solutions do not affect the participants' points and the time penalty.



A round lasts for t minutes. The time for reading problems and submitting solutions can be considered to equal zero. Vasya is allowed to submit a solution exactly at the moment when the round ends.

Vasya wants to choose a set of inputs and the order of their solution so as to make the expectation of the total received points maximum possible. If there are multiple ways to do this, he needs to minimize the expectation of the time penalty. Help Vasya to cope with this problem.

Input

The first line contains two integers n and t (1 ≤ n ≤ 1000, 1 ≤ t ≤ 1560). Then follow n lines, each containing 5 numbers: scoreSmalli, scoreLargei, timeSmalli, timeLargei, probFaili (1 ≤ scoreSmalli, scoreLargei ≤ 109, 1 ≤ timeSmalli, timeLargei ≤ 1560, 0 ≤ probFaili ≤ 1).

probFaili are real numbers, given with at most 6 digits after the decimal point. All other numbers in the input are integers.

Output

Print two real numbers — the maximum expectation of the total points and the corresponding minimum possible time penalty expectation. The answer will be considered correct if the absolute or relative error doesn't exceed 10 - 9.

Examples

Input

3 40
10 20 15 4 0.5
4 100 21 1 0.99
1 4 1 1 0.25


Output

24.0 18.875


Input

1 1
100000000 200000000 1 1 0


Output

100000000 1

Note

In the first sample one of the optimal orders of solving problems is:

  1. The Small input of the third problem. 
  2. The Small input of the first problem. 
  3. The Large input of the third problem. 
  4. The Large input of the first problem.



Note that if you solve the Small input of the second problem instead of two inputs of the third one, then total score expectation will be the same but the time penalty expectation will be worse (38).

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const double eps = 1e-10;
const long long linf = 1e18 + 7;
const long long hh = 523;
inline int read() {
  int x = 0;
  char ch = getchar();
  while (ch < '0' || ch > '9') ch = getchar();
  while (ch >= '0' && ch <= '9') {
    x = x * 10 + ch - '0';
    ch = getchar();
  }
  return x;
}
double fail[1007];
long double dp[1007][1567], t[1007][1567];
int n, tt;
struct problem {
  int ss, sl, ts, tl;
  double fail;
} p[1007];
bool d1(problem a, problem b) {
  return a.tl * a.fail / (1 - a.fail) < b.tl * b.fail / (1 - b.fail);
}
int main() {
  scanf("%d%d", &n, &tt);
  for (int i = 0; i < n; i++) {
    scanf("%d%d%d%d%lf", &p[i].ss, &p[i].sl, &p[i].ts, &p[i].tl, &p[i].fail);
  }
  sort(p, p + n, d1);
  for (int i = 0; i < n; i++) {
    for (int j = 0; j <= tt; j++) {
      dp[i][j] = -1;
    }
  }
  dp[0][tt] = 0;
  t[0][tt] = 0;
  for (int i = 0; i < n; i++) {
    for (int j = 0; j <= tt; j++) {
      if (dp[i][j] == -1) {
        continue;
      }
      if (j >= p[i].ts) {
        if (dp[i + 1][j - p[i].ts] < dp[i][j] + p[i].ss) {
          dp[i + 1][j - p[i].ts] = dp[i][j] + p[i].ss;
          t[i + 1][j - p[i].ts] = t[i][j] + p[i].ts;
        } else if (dp[i + 1][j - p[i].ts] == dp[i][j] + p[i].ss) {
          t[i + 1][j - p[i].ts] = min(t[i + 1][j - p[i].ts], t[i][j] + p[i].ts);
        }
      }
      if (j >= p[i].ts + p[i].tl) {
        if (dp[i + 1][j - p[i].ts - p[i].tl] <
            dp[i][j] + p[i].ss + p[i].sl * (1.0 - p[i].fail)) {
          dp[i + 1][j - p[i].ts - p[i].tl] =
              dp[i][j] + p[i].ss + p[i].sl * (1.0 - p[i].fail);
          t[i + 1][j - p[i].ts - p[i].tl] =
              p[i].ts + p[i].fail * t[i][j] +
              (1 - p[i].fail) * (p[i].tl + (tt - j));
        } else if (dp[i + 1][j - p[i].ts - p[i].tl] ==
                   dp[i][j] + p[i].ss + p[i].sl * (1.0 - p[i].fail)) {
          t[i + 1][j - p[i].ts - p[i].tl] =
              min(t[i + 1][j - p[i].ts - p[i].tl],
                  p[i].ts + p[i].fail * t[i][j] +
                      (1 - p[i].fail) * (p[i].tl + (tt - j)));
        }
      }
      if (dp[i + 1][j] < dp[i][j]) {
        dp[i + 1][j] = dp[i][j];
        t[i + 1][j] = t[i][j];
      } else if (dp[i + 1][j] == dp[i][j]) {
        t[i + 1][j] = min(t[i + 1][j], t[i][j]);
      }
    }
  }
  long double mx = 0, ans = linf;
  for (int i = 0; i <= tt; i++) {
    if (dp[n][i] > mx) {
      mx = dp[n][i];
      ans = t[n][i];
    } else if (dp[n][i] == mx) {
      ans = min(ans, t[n][i]);
    }
  }
  cout << fixed << setprecision(10) << mx << " " << ans << endl;
  return 0;
}