Airports often use moving walkways to help you walking big distances faster. Each such walkway has some speed that effectively increases your speed. You can stand on such a walkway and let it move you, or you could also walk and then your effective speed is your walking speed plus walkway's speed.

Limak wants to get from point 0 to point L on a straight line. There are n disjoint walkways in between. The i-th walkway is described by two integers x_i and y_i and a real value s_i. The i-th walkway starts at x_i, ends at y_i and has speed s_i. 

Every walkway is located inside the segment [0, L] and no two walkways have positive intersection. However, they can touch by endpoints.

Limak needs to decide how to distribute his energy. For example, it might make more sense to stand somewhere (or to walk slowly) to then have a lot of energy to walk faster.

Limak's initial energy is 0 and it must never drop below that value. At any moment, he can walk with any speed v in the interval [0, 2] and it will cost him v energy per second, but he continuously recovers energy with speed of 1 energy per second. So, when he walks with speed v, his energy increases by (1-v). Note that negative value would mean losing energy.

In particular, he can walk with speed 1 and this won't change his energy at all, while walking with speed 0.77 effectively gives him 0.23 energy per second.

Limak can choose his speed arbitrarily (any real value in interval [0, 2]) at every moment of time (including the moments when he is located on non-integer positions). Everything is continuous (non-discrete).

What is the fastest time Limak can get from 0 to L?

Input

The first line contains integers n and L (1 ≤ n ≤ 200 000, 1 ≤ L ≤ 10^9), the number of walkways and the distance to walk.

Each of the next n lines contains integers x_i, y_i and real value s_i (0 ≤ x_i < y_i ≤ L, 0.1 ≤ s_i ≤ 10.0). The value s_i is given with at most 9 digits after decimal point.

It's guaranteed, that no two walkways have a positive intersection. The walkways are listed from left to right. That is, y_i ≤ x_{i + 1} for 1 ≤ i ≤ n - 1.

Output

Print one real value, the fastest possible time to reach L. Your answer will be considered correct if its absolute or relative error won't exceed 10^{-9}.

Examples

Input


1 5
0 2 2.0


Output


3.000000000000


Input


1 5
2 4 0.91


Output


3.808900523560


Input


3 1000
0 990 1.777777
995 996 1.123456789
996 1000 2.0


Output


361.568848429553

Note

The drawings show the first two examples. In the first one, there is a walkway from 0 to 2 with speed 2.0 and Limak wants to get to point 5. The second example has a walkway from 2 to 4 with speed 0.91.

<image>

In the first example, one of optimal strategies is as follows.

  * Get from 0 to 2 by standing still on the walkway. It moves you with speed 2 so it takes 1 second and you save up 1 energy. 
  * Get from 2 to 4 by walking with max speed 2 for next 1 second. It takes 1 second again and the energy drops to 0. 
  * Get from 4 to 5 by walking with speed 1. It takes 1 second and the energy stays constant at the value 0. 



The total time is 1 + 1 + 1 = 3.
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& x) {
  return os << "(" << x.first << "," << x.second << ")";
}
struct SegTree {
  struct Node {
    long double mn = 0;
    long double prop = 0;
    void apply(int s, int e, long double v) {
      mn += v;
      prop += v;
    }
  };
  inline Node combine(const Node& a, const Node& b) {
    Node res;
    res.mn = min(a.mn, b.mn);
    return res;
  }
  inline void push(int sn, int s, int e) {
    if (tree[sn].prop != 0) {
      int m = (s + e) >> 1, lsn = sn * 2, rsn = sn * 2 + 1;
      tree[lsn].apply(s, m, tree[sn].prop);
      tree[rsn].apply(m + 1, e, tree[sn].prop);
      tree[sn].prop = 0;
    }
  }
  int start, end;
  vector<Node> tree;
  void build(int sn, int s, int e) {
    if (s == e) {
      return;
    }
    int m = (s + e) >> 1, lsn = sn * 2, rsn = sn * 2 + 1;
    build(lsn, s, m);
    build(rsn, m + 1, e);
    tree[sn] = combine(tree[lsn], tree[rsn]);
  }
  template <typename... T>
  void update(int sn, int s, int e, int qs, int qe, const T&... v) {
    if (qs <= s && e <= qe) {
      tree[sn].apply(s, e, v...);
      return;
    }
    int m = (s + e) >> 1, lsn = sn * 2, rsn = sn * 2 + 1;
    push(sn, s, e);
    if (qs <= m) update(lsn, s, m, qs, qe, v...);
    if (qe > m) update(rsn, m + 1, e, qs, qe, v...);
    tree[sn] = combine(tree[lsn], tree[rsn]);
  }
  Node query(int sn, int s, int e, int qs, int qe) {
    if (qs <= s && e <= qe) return tree[sn];
    int m = (s + e) >> 1, lsn = sn * 2, rsn = sn * 2 + 1;
    push(sn, s, e);
    if (qe <= m) return query(lsn, s, m, qs, qe);
    if (qs > m) return query(rsn, m + 1, e, qs, qe);
    return combine(query(lsn, s, m, qs, qe), query(rsn, m + 1, e, qs, qe));
  }
  void query(int sn, int s, int e, int qs, int qe,
             const function<void(Node&, int, int)>& f) {
    if (qs <= s && e <= qe) return f(tree[sn], s, e);
    int m = (s + e) >> 1, lsn = sn * 2, rsn = sn * 2 + 1;
    push(sn, s, e);
    if (qs <= m) query(lsn, s, m, qs, qe, f);
    if (qe > m) query(rsn, m + 1, e, qs, qe, f);
  }
  SegTree(int n) : SegTree(0, n - 1) {}
  SegTree(int _start, int _end) : start(_start), end(_end) {
    int n = end - start + 1;
    int maxs = n == 1 ? 2 : 1 << (33 - __builtin_clz(n - 1));
    tree.resize(maxs);
    build(1, start, end);
  }
  template <typename T>
  SegTree(vector<T>& v) {
    int n = v.size();
    int maxs = n == 1 ? 2 : 1 << (33 - __builtin_clz(n - 1));
    tree.resize(maxs);
    start = 0;
    end = n - 1;
    build(1, start, end, v);
  }
  Node query(int qs, int qe) { return query(1, start, end, qs, qe); }
  Node query(int p) { return query(1, start, end, p, p); }
  void query(int qs, int qe, const function<void(Node&, int, int)>& f) {
    if (qs > qe) return;
    query(1, start, end, qs, qe, f);
  }
  template <typename... T>
  void update(int qs, int qe, const T&... v) {
    update(1, start, end, qs, qe, v...);
  }
};
int main() {
  int n, L;
  scanf("%d%d", &n, &L);
  vector<int> x(n + 1), y(n + 1);
  vector<pair<int, long long>> segs;
  const long long ONE = 1e9;
  for (int i = 1; i <= n; ++i) {
    long double s;
    scanf("%d%d%Lf", &x[i], &y[i], &s);
    long long d = llround(s * 1e9);
    if (x[i] > y[i - 1]) {
      segs.push_back({x[i] - y[i - 1], 0});
    }
    segs.push_back({y[i] - x[i], d});
  }
  if (y[n] != L) segs.push_back({L - y[n], 0});
  int m = segs.size();
  vector<int> ids(m);
  iota(ids.begin(), ids.end(), 0);
  sort(ids.begin(), ids.end(),
       [&](int a, int b) { return segs[a].second < segs[b].second; });
  vector<long double> amt(m);
  long double ans = 0;
  SegTree st(m);
  for (int i = 0; i < m; ++i) {
    long double vi;
    if (!segs[i].second) {
      vi = 1;
      amt[i] = segs[i].first / (vi + 1);
    } else {
      vi = (long double)segs[i].second / ONE;
      amt[i] = segs[i].first / vi + segs[i].first / (vi + 2);
      st.update(i, m - 1, segs[i].first / vi);
    }
    ans += segs[i].first / vi;
  }
  for (int i : ids) {
    auto x = st.query(i, m - 1);
    long double e = x.mn;
    e = min(e, amt[i]);
    long double vi = (long double)(segs[i].second + ONE) / ONE;
    ans -= e / vi;
    st.update(i, m - 1, -e);
  }
  printf("%.12Lf\n", ans);
}
