#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

void solve(int n, int m) {
  vector<vector<int>> stacks(m);
  vector<pair<int, int>> id(n, make_pair(-1, -1));
  for (int i = 0; i < m; ++i) {
    int k;
    cin >> k;
    stacks[i].resize(k);
    for (int j = 0; j < k; ++j) {
      cin >> stacks[i][j];
      --stacks[i][j];
      if (id[stacks[i][j]].first == -1)
        id[stacks[i][j]].first = i;
      else
        id[stacks[i][j]].second = i;
    }
  }
  vector<pair<int, int>> ans;
  set<int> empty;
  for (int i = 0; i < m; ++i) {
    if (stacks[i].empty())
      empty.emplace(i);
  }
  auto do_move = [&](int from, int to) {
    int r = stacks[from].back();
    stacks[from].pop_back();
    if (id[r].first == from)
      id[r].first = to;
    else
      id[r].second = to;
    stacks[to].emplace_back(r);
    if (stacks[from].empty())
      empty.emplace(from);
    if (stacks[to].size() == 1)
      empty.erase(to);
    ans.emplace_back(from, to);

    /*for (int i = 0; i < m; ++i) {
      for (int x : stacks[i])
        cerr << x;
      cerr << '\t';
    }
    cerr << '\n';*/

  };
  auto is_up = [&](int c, int i) {
    return stacks[i].back() == c;
  };
  deque<int> Q;
  for (int i = 0; i < n; ++i) {
    auto [a, b] = id[i];
    if (stacks[a].size() == 1 && stacks[b].size() == 1) {
      Q.emplace_back(i);
    } else if (stacks[a].size() == 1) {
      if (is_up(i, b))
        Q.emplace_back(i);
    } else if (stacks[b].size() == 1) {
      if (is_up(i, a))
        Q.emplace_back(i);
    }
  }
  while (!Q.empty()) {
    int i = Q.front();
    cerr << "q : " << i << '\n';
    Q.pop_front();
    auto [a, b] = id[i];
    if (stacks[a].size() == 1 && stacks[b].size() == 1) {
      do_move(a, b);
    } else if (stacks[a].size() == 1) {
      do_move(b, a);
      int j = stacks[b][0];
      int c = b ^ id[j].first ^ id[j].second;
      if (is_up(j, c))
        Q.emplace_back(j);
    } else {
      do_move(a, b);
      int j = stacks[a][0];
      int c = a ^ id[j].first ^ id[j].second;
      if (is_up(j, c))
        Q.emplace_back(j);
    }
  }
  auto fix_path = [&](int c) {
    vector<int> cols;
    vector<int> stack_ids;
    int cur_stack;
    auto [a, b] = id[c];
    if (stacks[a].size() == 1 && stacks[b].size() == 1) {
      do_move(a, b);
      return true;
    }
    if (stacks[a].size() == 1) {
      stack_ids.emplace_back(a);
      cur_stack = b;
    } else {
      stack_ids.emplace_back(b);
      cur_stack = a;
    }
    while (true) {
      cols.emplace_back(c);
      stack_ids.emplace_back(cur_stack);
      if (stacks[cur_stack].size() == 1)
        break;
      int c2 = stacks[cur_stack][0] ^ stacks[cur_stack][1] ^ c;
      int stack2 = id[c2].first ^ id[c2].second ^ cur_stack;
      c = c2;
      cur_stack = stack2;
    }
    int st = 0;
    while (st < cols.size()) {
      int i = st;
      while (stacks[stack_ids[i + 1]][0] == cols[i])
        ++i;
      int mid = i;
      while (i < cols.size() && stacks[stack_ids[i + 1]].back() == cols[i])
        ++i;
      if (empty.empty())
        return false;
      int e = *empty.begin();
      do_move(stack_ids[mid], e);
      do_move(stack_ids[mid + 1], e);
      for (int j = mid; j > st; --j)
        do_move(stack_ids[j - 1], stack_ids[j]);
      for (int j = mid + 1; j < i; ++j)
        do_move(stack_ids[j + 1], stack_ids[j]);
      st = i;
    }
    return true;
  };
  for (int i = 0; i < n; ++i) {
    auto [a, b] = id[i];
    if (stacks[a].size() == 1 || stacks[b].size() == 1) {
      if (!fix_path(i)) {
        cout << -1 << '\n';
        return;
      }
    }
  }
  // cycles
  for (int i = 0; i < n; ++i) {
    auto [a, b] = id[i];
    if (a == b)
      continue;

    vector<int> cols;
    int cur_c = i;
    int pre_i = a;
    while (true) {
      cols.emplace_back(cur_c);
      int stack_id = id[cur_c].first ^ id[cur_c].second ^ pre_i;
      int c2 = stacks[stack_id][0] ^ stacks[stack_id][1] ^ cur_c;
      cur_c = c2;
      pre_i = stack_id;
      if (cur_c == i)
        break;
    }
    int both_up = -1;
    for (int c : cols) {
      auto [i1, j1] = id[c];
      if (is_up(c, i1) && is_up(c, j1))
        both_up = c;
    }
    if (both_up == -1) {
      // good cycle
      if (!is_up(i, b)) {
        reverse(cols.begin() + 1, cols.end());
        swap(a, b);
      }
      if (empty.empty()) {
        cout << -1 << '\n';
        return;
      }
      for (int c : cols)
        cerr << c << ' ';
      cerr << '\n';
      int e = *empty.begin();
      do_move(b, e);
      pre_i = b;
      for (int j = 1; j < cols.size(); ++j) {
        int c = cols[j];
        int cur_i = id[c].first ^ id[c].second ^ pre_i;
        do_move(cur_i, pre_i);
        pre_i = cur_i;
      }
      do_move(pre_i, e);
    } else {
      // bad cycle
      vector<int> c;
      vector<int> d;
      vector<int> is;
      vector<int> js;
      pre_i = id[both_up].first;
      cur_c = stacks[pre_i][0] ^ stacks[pre_i][1] ^ both_up;
      while (!is_up(cur_c, pre_i)) {
        c.emplace_back(cur_c);
        is.emplace_back(pre_i);
        int cur_i = id[cur_c].first ^ id[cur_c].second ^ pre_i;
        int c2 = stacks[cur_i][0] ^ stacks[cur_i][1] ^ cur_c;
        cur_c = c2;
        pre_i = cur_i;
      }
      pre_i = id[both_up].second;
      cur_c = stacks[pre_i][0] ^ stacks[pre_i][1] ^ both_up;
      while (!is_up(cur_c, pre_i)) {
        d.emplace_back(cur_c);
        js.emplace_back(pre_i);
        int cur_i = id[cur_c].first ^ id[cur_c].second ^ pre_i;
        int c2 = stacks[cur_i][0] ^ stacks[cur_i][1] ^ cur_c;
        cur_c = c2;
        pre_i = cur_i;
      }
      if (empty.empty()) {
        cout << -1 << '\n';
        return;
      }
      int e = *empty.begin(); 
      do_move(is[0], e);
      do_move(js[0], e);
      for (int i = 1; i < is.size(); ++i)
        do_move(is[i], is[i - 1]);
      for (int i = 1; i < js.size(); ++i)
        do_move(js[i], js[i - 1]);
      if (!fix_path(c.back())) {
        cout << -1 << '\n';
        return;
      }
    }
  }
  cout << ans.size() << '\n';
  for (auto [a, b] : ans)
    cout << a + 1 << ' ' << b + 1 << '\n';
}


int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);

  int n, m;
  while (cin >> n >> m) {
    solve(n, m);
  }
  return 0;
}