#include <bits/stdc++.h>
using namespace std;
struct frac {
  long long p;
  long long q;
  frac(long long p_, long long q_) {
    p = p_;
    q = q_;
    p_ = abs(p_);
    q_ = abs(q_);
    while (q_ > 0) {
      long long t = p_ % q_;
      p_ = q_;
      q_ = t;
    }
    p /= p_;
    q /= p_;
    if (q < 0) {
      q *= -1;
      p *= -1;
    }
  }
  bool operator<(const frac& f) const {
    if (p != f.p) {
      return p < f.p;
    } else {
      return q < f.q;
    }
  }
  bool operator==(const frac& f) const { return p == f.p && q == f.q; }
};
struct point {
  frac x;
  frac y;
  bool operator<(const point& f) const {
    if (!(x == f.x)) {
      return x < f.x;
    } else {
      return y < f.y;
    }
  }
  bool operator==(point f) { return x == f.x && y == f.y; }
};
struct line {
  long long a;
  long long b;
  long long c;
  int id;
};
int n, k;
line ll;
vector<line> lines;
vector<pair<int, int> > res;
bool parallel(line l1, line l2) { return l1.a * l2.b == l2.a * l1.b; }
point inter(line l1, line l2) {
  long long det = l1.b * l2.a - l2.b * l1.a;
  return point{frac(l2.c * l1.b - l1.c * l2.b, det),
               frac(l2.c * l1.a - l1.c * l2.a, det)};
}
bool common(line l1, line l2, line l3) {
  if (parallel(l1, l2) || parallel(l2, l3)) {
    return false;
  }
  return inter(l1, l2) == inter(l2, l3);
}
bool dfs(vector<line>& lines, int k) {
  int n = lines.size();
  if (k <= 0) {
    return n <= 0;
  }
  if (n <= k) {
    for (auto x : lines) {
      res.push_back({x.id, -1});
    }
    return true;
  }
  int m = n;
  int big = (n + k - 1) / k;
  set<point> branched;
  if (n > k * k) {
    m = k * k + 1;
    big = k + 1;
  }
  for (int i = 0; i < m; i++) {
    for (int j = i + 1; j < m; j++) {
      if (parallel(lines[i], lines[j])) {
        continue;
      }
      vector<int> here{i, j};
      point its = inter(lines[i], lines[j]);
      if (branched.count(its) != 0) {
        continue;
      }
      branched.insert(its);
      for (int l = j + 1; l < m; l++) {
        if (common(lines[i], lines[j], lines[l])) {
          here.push_back(l);
        }
      }
      if (here.size() >= big) {
        vector<line> rest;
        res.push_back({lines[i].id, lines[j].id});
        for (int l = 0; l < n; l++) {
          if (l != i && l != j && !common(lines[i], lines[j], lines[l])) {
            rest.push_back(lines[l]);
          }
        }
        bool ret = dfs(rest, k - 1);
        if (n > k * k) {
          return ret;
        } else {
          if (ret) {
            return true;
          }
          res.pop_back();
        }
      }
    }
  }
  return false;
}
int main() {
  scanf("%d %d", &n, &k);
  for (int i = 0; i < n; i++) {
    scanf("%I64d %I64d %I64d", &ll.a, &ll.b, &ll.c);
    ll.id = i + 1;
    lines.push_back(ll);
  }
  if (dfs(lines, k)) {
    puts("YES");
    printf("%d\n", res.size());
    for (auto p : res) {
      printf("%d %d\n", p.first, p.second);
    }
  } else {
    puts("NO");
  }
  return 0;
}
