Problem: Gleb is a famous competitive programming teacher from Innopolis. He is planning a trip to N programming camps in the nearest future. Each camp will be held in a different country. For each of them, Gleb needs to apply for a visa. 

For each of these trips Gleb knows three integers: the number of the first day of the trip si, the length of the trip in days leni, and the number of days ti this country's consulate will take to process a visa application and stick a visa in a passport. Gleb has P (1 ≤ P ≤ 2) valid passports and is able to decide which visa he wants to put in which passport.

For each trip, Gleb will have a flight to that country early in the morning of the day si and will return back late in the evening of the day si + leni - 1.

To apply for a visa on the day d, Gleb needs to be in Innopolis in the middle of this day. So he can't apply for a visa while he is on a trip, including the first and the last days. If a trip starts the next day after the end of the other one, Gleb can't apply for a visa between them as well. The earliest Gleb can apply for a visa is day 1.

After applying for a visa of country i on day d, Gleb will get his passport back in the middle of the day d + ti. Consulates use delivery services, so Gleb can get his passport back even if he is not in Innopolis on this day. Gleb can apply for another visa on the same day he received his passport back, if he is in Innopolis this day. 

Gleb will not be able to start his trip on day si if he doesn't has a passport with a visa for the corresponding country in the morning of day si. In particular, the passport should not be in another country's consulate for visa processing.

Help Gleb to decide which visas he needs to receive in which passport, and when he should apply for each visa. 

Input

In the first line of the input there are two integers N (1 ≤ N ≤ 22) and P (1 ≤ P ≤ 2)—the number of trips and the number of passports Gleb has, respectively.

The next N lines describe Gleb's trips. Each line contains three positive integers si, leni, ti (1 ≤ si, leni, ti ≤ 109)—the first day of the trip, the length of the trip and number of days the consulate of this country needs to process a visa application. It is guaranteed that no two trips intersect.

Output

If it is impossible to get all visas on time, just print "NO" (quotes for clarity). Otherwise, print "YES" and N lines describing trips. For each trip, first print number of the passport Gleb should put this country's visa in, and then print number of the day he should apply for it. Print trips in the same order as they appear in the input. Days are numbered from 1, starting with tomorrow—the first day you can apply for a visa. Passports are numbered from 1 to P.

If there are several possible answers, print any of them.

Examples

Input

2 1
3 1 1
6 1 1


Output

YES
1 1
1 4


Input

3 1
13 2 2
7 3 1
19 3 4


Output

YES
1 10
1 1
1 2


Input

7 2
15 1 1
14 1 1
18 1 1
21 1 1
9 4 6
22 2 5
5 4 3


Output

YES
2 13
1 1
1 16
1 19
1 2
2 16
2 1


Input

3 1
7 3 1
13 2 3
19 3 4


Output

NO

Note

Examples with answer "YES" are depicted below.

Each cell of the stripe represents a single day. Rectangles represent trips, each trip starts in the morning and ends in the evening. Rectangles with angled corners represent visa applications. Each application starts in the middle of a day and ends ti days after. The trip and the visa application for the same country have the same color.

In examples with two passports, visa applications and trips depicted above the time stripe are made using the first passport, visa applications and trips depicted below the time stripe are made using the second passport.

Example 1: 

<image>

Example 2: 

<image>

Example 3: 

<image>

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
  i >> p.first >> p.second;
  return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
  for (auto& v : t) {
    i >> v;
  }
  return i;
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {
  o << p.first << ' ' << p.second;
  return o;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
  if (t.empty()) o << '\n';
  for (size_t i = 0; i < t.size(); ++i) {
    o << t[i] << " \n"[i == t.size() - 1];
  }
  return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
template <typename T>
bool in(T a, T b, T c) {
  return a <= b && b < c;
}
unsigned int logceil(long long first) {
  return first ? 8 * sizeof(long long) - __builtin_clzll(first) : 0;
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
  hash<T> t;
  hash<U> u;
  size_t operator()(const pair<T, U>& p) const {
    return t(p.first) ^ (u(p.second) << 7);
  }
};
}  // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F& f) {
  T r = -1, m;
  while (l <= h) {
    m = (l + h) / 2;
    if (f(m)) {
      l = m + 1;
      r = m;
    } else {
      h = m - 1;
    }
  }
  return r;
}
template <typename F>
double bshd(double l, double h, const F& f, double p = 1e-9) {
  unsigned int r = 3 + (unsigned int)log2((h - l) / p);
  while (r--) {
    double m = (l + h) / 2;
    if (f(m)) {
      l = m;
    } else {
      h = m;
    }
  }
  return (l + h) / 2;
}
template <typename T, typename F>
T bsl(T l, T h, const F& f) {
  T r = -1, m;
  while (l <= h) {
    m = (l + h) / 2;
    if (f(m)) {
      h = m - 1;
      r = m;
    } else {
      l = m + 1;
    }
  }
  return r;
}
template <typename F>
double bsld(double l, double h, const F& f, double p = 1e-9) {
  unsigned int r = 3 + (unsigned int)log2((h - l) / p);
  while (r--) {
    double m = (l + h) / 2;
    if (f(m)) {
      h = m;
    } else {
      l = m;
    }
  }
  return (l + h) / 2;
}
template <typename T>
T gcd(T a, T b) {
  if (a < b) swap(a, b);
  return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
 public:
  vector2() {}
  vector2(size_t a, size_t b, T t = T())
      : vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector2<T>> {
 public:
  vector3() {}
  vector3(size_t a, size_t b, size_t c, T t = T())
      : vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template <typename T>
class vector4 : public vector<vector3<T>> {
 public:
  vector4() {}
  vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
      : vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template <typename T>
class vector5 : public vector<vector4<T>> {
 public:
  vector5() {}
  vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
      : vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};
class FPassports {
 public:
  void solve(istream& cin, ostream& cout) {
    int N, P;
    cin >> N >> P;
    vector<pair<std::pair<int, int>, std::pair<int, int>>> T(N);
    for (int i = 0; i < N; ++i) {
      cin >> T[i].first.first >> T[i].first.second >> T[i].second.first;
      T[i].second.second = i;
    }
    sort(T.begin(), T.end());
    int inf = 2e9;
    vector<pair<int, std::pair<int, int>>> W(1 << N, {inf, {-1, 0}});
    W[0].first = 1;
    for (int b = 0; b < (1 << N); ++b) {
      if (W[b].first == inf) continue;
      int first = 0;
      while (first < N &&
             (T[first].first.first + T[first].first.second < W[b].first))
        ++first;
      int bar = first;
      while (bar < N &&
             T[bar].first.first + T[bar].first.second - 1 < W[b].first)
        ++bar;
      bool canApplyRightAway = !(bar < N && T[bar].first.first <= W[b].first);
      int earliestAfter = first;
      while (earliestAfter < N && (T[earliestAfter].first.first < W[b].first ||
                                   ((b & (1 << earliestAfter)) == 0)))
        ++earliestAfter;
      for (int g = first; g < N; ++g) {
        if (b & (1 << g)) continue;
        int apply = W[b].first;
        int passBack = apply + T[g].second.first;
        if (T[g].first.first <= passBack) continue;
        if (canApplyRightAway && !(earliestAfter != N &&
                                   W[b].first <= T[earliestAfter].first.first &&
                                   T[earliestAfter].first.first <= passBack)) {
          W[b | (1 << g)] = min(W[b | (1 << g)], {passBack, {g, apply}});
        } else {
          int foo = first;
          for (int k = first; k <= N; ++k) {
            int apply = k == first
                            ? W[b].first
                            : T[k - 1].first.first + T[k - 1].first.second;
            int passBack = apply + T[g].second.first;
            if (T[g].first.first <= passBack) break;
            if (k == first) {
              if (!canApplyRightAway) continue;
            } else {
              if (k != N && T[k].first.first == apply) continue;
            }
            if (k == first) {
              if (earliestAfter != N &&
                  W[b].first <= T[earliestAfter].first.first &&
                  T[earliestAfter].first.first <= passBack)
                continue;
            } else {
              while (foo < N &&
                     (T[foo].first.first < apply || ((b & (1 << foo)) == 0)))
                ++foo;
              if (foo != N && apply <= T[foo].first.first &&
                  T[foo].first.first <= passBack)
                continue;
            }
            W[b | (1 << g)] = min(W[b | (1 << g)], {passBack, {g, apply}});
            break;
          }
        }
      }
    }
    vector<std::pair<int, int>> Ans(N);
    if (P == 1) {
      if (W[(1 << N) - 1].first == inf) {
        cout << "NO\n";
        return;
      } else {
        int m = (1 << N) - 1;
        while (m != 0) {
          Ans[T[W[m].second.first].second.second] = {1, W[m].second.second};
          m ^= 1 << W[m].second.first;
        }
      }
    }
    if (P == 2) {
      bool found = false;
      for (int m = 0; m < (1 << N); ++m) {
        int c = ((1 << N) - 1) ^ m;
        if (W[m].first != inf && W[c].first != inf) {
          while (m != 0) {
            Ans[T[W[m].second.first].second.second] = {1, W[m].second.second};
            m ^= 1 << W[m].second.first;
          }
          while (c != 0) {
            Ans[T[W[c].second.first].second.second] = {2, W[c].second.second};
            c ^= 1 << W[c].second.first;
          }
          found = true;
          break;
        }
      }
      if (!found) {
        cout << "NO\n";
        return;
      }
    }
    cout << "YES\n";
    for (std::pair<int, int> ans : Ans) cout << ans << endl;
  }
};
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
  cout.tie(nullptr);
  FPassports solver;
  std::istream& in(std::cin);
  std::ostream& out(std::cout);
  solver.solve(in, out);
  return 0;
}