#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector")
using namespace std;
using lli = long long;
using ld = long double;
using ii = pair<lli, int>;
using vi = vector<int>;
const int N = 1e5 + 5;
const lli inf = 1e15 + 7;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
struct Seg {
  int l, r;
  lli a, b;
  int pa, push_back;
  Seg *ls, *rs;
  Seg(int l, int r) : l(l), r(r), ls(0), rs(0) {
    if (l == r) {
      a = b = inf;
      pa = push_back = l;
      return;
    }
    int m = (l + r) >> 1;
    ls = new Seg(l, m);
    rs = new Seg(m + 1, r);
    pull();
  }
  void pull() {
    a = min(ls->a, rs->a);
    b = min(ls->b, rs->b);
    pa = (ls->a == a ? ls->pa : rs->pa);
    push_back = (ls->b == b ? ls->push_back : rs->push_back);
  }
  void update(int p, lli v, bool t) {
    if (l == r) {
      if (t)
        a = v;
      else
        b = v;
      return;
    }
    int m = (l + r) >> 1;
    if (p <= m)
      ls->update(p, v, t);
    else
      rs->update(p, v, t);
    pull();
  }
  ii qmin(int ll, int rr, bool t) {
    if (rr < l || r < ll || rr < ll) return make_pair(inf, -1);
    if (ll <= l && r <= rr) {
      if (t) {
        return make_pair(a, pa);
      } else {
        return make_pair(b, push_back);
      }
    }
    return min(ls->qmin(ll, rr, t), rs->qmin(ll, rr, t));
  }
};
struct Ramp {
  lli l, r, time;
  int idx;
  friend ostream &operator<<(ostream &os, const Ramp &a) {
    return os << "(" << a.l << ' ' << a.r << ' ' << a.time << ")";
  }
};
Ramp ramps[N];
bool leq(int k, int l) { return ramps[k].r <= l; }
int first(int i, int l) {
  int lo = 0, hi = i - 1;
  while (lo < hi - 1) {
    int mid = (lo + hi) >> 1;
    if (leq(mid, l))
      lo = mid;
    else
      hi = mid - 1;
  }
  return (leq(hi, l) ? hi : lo);
}
lli mn[N];
lli pre[N];
Seg *tree;
void run_case() {
  int n;
  lli L;
  cin >> n >> L;
  int K = 0;
  for (auto i = (1) - ((1) > (n + 1)); i != n + 1 - ((1) > (n + 1));
       i += 1 - 2 * ((1) > (n + 1))) {
    lli x, d, t, p;
    cin >> x >> d >> t >> p;
    if (x - p >= 0) {
      ramps[++K] = {x - p, x + d, t + p, i};
    }
  }
  sort(ramps + 1, ramps + K + 1, [&](Ramp a, Ramp b) { return a.r < b.r; });
  ;
  tree = new Seg(0, N);
  ramps[K + 1] = Ramp{L, L, 0, -1};
  fill(begin(pre), end(pre), -1);
  fill(begin(mn), end(mn), L);
  for (auto i = (1) - ((1) > (K + 2)); i != K + 2 - ((1) > (K + 2));
       i += 1 - 2 * ((1) > (K + 2))) {
    auto [l, r, timer, wtf] = ramps[i];
    mn[i] = l;
    pre[i] = -1;
    int k = first(i, l);
    auto [op0, place0] = tree->qmin(1, k, 0);
    auto [op1, place1] = tree->qmin(k + 1, i - 1, 1);
    ;
    op0 += l;
    op1 -= l;
    if (op0 < mn[i]) {
      mn[i] = op0;
      pre[i] = place0;
    }
    if (op1 < mn[i]) {
      mn[i] = op1;
      pre[i] = place1;
    };
    ;
    ;
    ;
    ;
    tree->update(i, mn[i] + timer - r, 0);
    tree->update(i, mn[i] + timer + r, 1);
  };
  vi ans;
  int idx = pre[K + 1];
  lli res = 0;
  int last = L;
  while (idx != -1) {
    res += abs(ramps[idx].r - last) + ramps[idx].time;
    last = ramps[idx].l;
    ans.emplace_back(ramps[idx].idx);
    idx = pre[idx];
  }
  reverse(begin(ans), end(ans));
  res += last;
  ;
  if (mn[K + 1] != res) {
    cout << mn[K + 1] << ' ' << res << '\n';
    exit(0);
  }
  assert(mn[K + 1] == res);
  assert(1 <= mn[K + 1] && mn[K + 1] <= L);
  cout << mn[K + 1] << '\n';
  cout << (int)(ans.size()) << '\n';
  for (int idx : ans) {
    assert(1 <= idx && idx <= n);
    cout << idx;
    if (idx != ans.back()) cout << ' ';
  }
  if (!ans.empty()) cout << '\n';
}
int main() {
  cin.tie(0)->sync_with_stdio(0), cout.tie(0);
  int t = 1;
  while (t--) {
    run_case();
  }
  return 0;
}
