#include <bits/stdc++.h>
std::map<int, int> track_points;
std::vector<std::vector<std::pair<int, std::pair<int, int> > > >
    graph_of_tracks;
const int MAX = 1001;
const int MAXINT = 1000000001;
void Dijcstra(int start_p = 0, int end_p = -1) {
  if (end_p == -1) {
    end_p = graph_of_tracks.size();
  }
  std::set<std::pair<int, int> > queue;
  std::vector<int> optimal_track(graph_of_tracks.size(), MAXINT);
  std::vector<std::pair<int, int> > sequence_track(graph_of_tracks.size());
  optimal_track[start_p] = 0;
  queue.insert(std::pair<int, int>(0, start_p));
  while (!queue.empty()) {
    int start_point_indx = queue.begin()->second;
    int start_track = queue.begin()->first;
    queue.erase(queue.begin());
    for (std::vector<std::pair<int, std::pair<int, int> > >::iterator
             point_iter = ::graph_of_tracks[start_point_indx].begin();
         point_iter != ::graph_of_tracks[start_point_indx].end();
         ++point_iter) {
      int end_point_indx = (*point_iter).first;
      int cost = (*point_iter).second.first;
      int used_jump_indx = (*point_iter).second.second;
      if (start_track + cost < optimal_track[end_point_indx]) {
        if (optimal_track[end_point_indx] != MAXINT) {
          queue.erase(queue.find(std::pair<int, int>(
              optimal_track[end_point_indx], end_point_indx)));
        }
        optimal_track[end_point_indx] = start_track + cost;
        sequence_track[end_point_indx] =
            std::pair<int, int>(start_point_indx, used_jump_indx);
        queue.insert(std::pair<int, int>(start_track + cost, end_point_indx));
      }
    }
  }
  std::vector<int> optimal_jumps;
  int point_indx = end_p;
  while (point_indx != 0) {
    int jump_indx = sequence_track[point_indx].second;
    if (jump_indx != 0) {
      optimal_jumps.push_back(jump_indx);
    }
    point_indx = sequence_track[point_indx].first;
  }
  std::cout << optimal_track[end_p] << std::endl;
  std::cout << optimal_jumps.size() << std::endl;
  for (std::vector<int>::reverse_iterator it = optimal_jumps.rbegin();
       it != optimal_jumps.rend(); ++it) {
    std::cout << (*it) << " ";
  }
}
int getIndxOfTrackPoint(int point_pos) {
  int point_indx;
  if (::track_points.find(point_pos) == ::track_points.end()) {
    point_indx = ::graph_of_tracks.size();
    ::track_points.insert(std::pair<int, int>(point_pos, point_indx));
    ::graph_of_tracks.push_back(
        std::vector<std::pair<int, std::pair<int, int> > >());
  } else {
    point_indx = ::track_points.find(point_pos)->second;
  }
  return point_indx;
}
int main() {
  int numb_of_jump, track_length;
  std::cin >> numb_of_jump >> track_length;
  ::track_points.insert(std::pair<int, int>(0, 0));
  ::track_points.insert(std::pair<int, int>(track_length, 1));
  ::graph_of_tracks.push_back(
      std::vector<std::pair<int, std::pair<int, int> > >());
  ::graph_of_tracks.push_back(
      std::vector<std::pair<int, std::pair<int, int> > >());
  for (int jump_indx = 0; jump_indx < numb_of_jump; ++jump_indx) {
    int jump_pos, pre_jump_pos, post_jump_pos, jump_time, pre_jump_pos_rltv,
        post_jump_pos_rltv, jump_time_real;
    std::cin >> jump_pos >> post_jump_pos_rltv >> jump_time >>
        pre_jump_pos_rltv;
    pre_jump_pos = jump_pos - pre_jump_pos_rltv;
    post_jump_pos = jump_pos + post_jump_pos_rltv;
    jump_time_real = jump_time + pre_jump_pos_rltv;
    if (pre_jump_pos < 0) {
      continue;
    }
    int start_jump_point_indx, end_jump_point_indx;
    start_jump_point_indx = getIndxOfTrackPoint(pre_jump_pos);
    end_jump_point_indx = getIndxOfTrackPoint(post_jump_pos);
    ::graph_of_tracks[start_jump_point_indx].push_back(
        std::pair<int, std::pair<int, int> >(
            end_jump_point_indx,
            std::pair<int, int>(jump_time_real, jump_indx + 1)));
  }
  std::map<int, int>::iterator iter_point = track_points.begin();
  int pre_point_pos = (*iter_point).first;
  int pre_point_indx = (*iter_point).second;
  int cur_point_pos, cur_point_indx;
  ++iter_point;
  for (; iter_point != ::track_points.end(); ++iter_point) {
    cur_point_pos = (*iter_point).first;
    cur_point_indx = (*iter_point).second;
    ::graph_of_tracks[pre_point_indx].push_back(
        std::pair<int, std::pair<int, int> >(
            cur_point_indx,
            std::pair<int, int>((cur_point_pos - pre_point_pos), 0)));
    ::graph_of_tracks[cur_point_indx].push_back(
        std::pair<int, std::pair<int, int> >(
            pre_point_indx,
            std::pair<int, int>((cur_point_pos - pre_point_pos), 0)));
    pre_point_pos = cur_point_pos;
    pre_point_indx = cur_point_indx;
  }
  Dijcstra(0, 1);
  return 0;
}
