#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#define debug(...) fprintf(stderr, ##__VA_ARGS__)
#else
#define endl "\n"
#define debug(...) void(0)
#endif
using LL = long long;
template <class T>
using pqueue_less = priority_queue<T, vector<T>, greater<T>>;
template <class Cap, class Cst>
struct mcf_graph { /*{{{*/
  const Cst maxc = numeric_limits<Cst>::max();
  struct edge {
    int v, rid;
    Cap cap;
    Cst cst;
  };
  int n;
  vector<vector<edge>> g;
  vector<Cst> h, dis;
  vector<int> pre;
  mcf_graph() = default;
  mcf_graph(int _n) : n(_n), g(_n) {}
  int addedge(int u, int v, Cap cap, Cst cst) {
    int tid = (int)g[u].size(), rid = (int)g[v].size() + (u == v);
    g[u].push_back({v, rid, cap, cst});
    g[v].push_back({u, tid, 0, -cst});
    return rid;
  }
  bool dijkstra(int s, int t) {
    vis.assign(n, false);
    pre.assign(n, -1);
    dis.assign(n, maxc);
    pqueue_less<pair<Cst, int>> q;
    q.emplace(dis[s] = 0, s);
    while (!q.empty()) {
      int u = q.top().second;
      q.pop();
      if (exchange(vis[u], true)) continue;
      for (auto e : g[u]) {
        auto w = h[u] - h[e.v] + e.cst;
        if (e.cap && dis[e.v] > dis[u] + w) {
          assert(w >= 0);
          pre[e.v] = e.rid;
          q.emplace(dis[e.v] = dis[u] + w, e.v);
        }
      }
    }
    return vis[t];
  }
  vector<int> vis, cur;
  Cap dfs(int u, Cap flw, int t) {
    if (u == t) return flw;
    vis[u] = true;
    Cap run = 0;
    for (int &i = cur[u]; i < (int)g[u].size(); i++) {
      auto &e = g[u][i];
      if (e.cap && !vis[e.v] && h[e.v] == h[u] + e.cst) {
        auto f = dfs(e.v, min(flw - run, e.cap), t);
        run += f, e.cap -= f, g[e.v][e.rid].cap += f;
        if (run == flw) break;
      }
    }
    if (run == flw) vis[u] = false;
    return run;
  }
  struct result_type {
    Cap cap;
    Cst cst;
  };
  template <bool op = false>
  result_type flow(int s, int t, Cap lim = numeric_limits<Cap>::max()) {
    Cap flw = 0;
    Cst cst = 0;
    if (h.empty()) h.assign(n, 0);
    dijkstra(s, t);
    for (int i = 0; i < n; i++)
      if (dis[i] < maxc) h[i] += dis[i];
    auto hs = h[s];
    for (int i = 0; i < n; i++) h[i] -= hs;
    while (flw < lim && dijkstra(s, t)) {
      if (op && h[t] >= 0) break;
      for (int i = 0; i < n; i++)
        if (dis[i] < maxc) h[i] += dis[i];
      //    Cap run = lim - flw;
      //    for (int v = t, u; v != s; v = u) {
      //      u = g[v][pre[v]].v;
      //      run = min(run, g[u][g[v][pre[v]].rid].cap);
      //    }
      //    for (int v = t, u; v != s; v = u) {
      //      u = g[v][pre[v]].v;
      //      g[u][g[v][pre[v]].rid].cap -= run;
      //      g[v][pre[v]].cap += run;
      //    }
      vis.assign(n, false);
      cur.assign(n, 0);
      auto run = dfs(s, lim - flw, t);
      flw += run, cst += run * h[t];
    }
    return {flw, cst};
  }
}; /*}}}*/
template <class Cap, class Cst>
struct mcf_interface { 
  int n;
  vector<Cap> d;
  mcf_graph<Cap, Cst> mf;
  Cap cap{};
  Cst val{};
  vector<pair<int, int>> ids;
  mcf_interface() = default;
  mcf_interface(int _n) : n(_n), d(_n), mf(_n + 2) {}
  void addedge(int u, int v, Cap f, Cst c) {
    int id;
    if (c >= 0)
      id = mf.addedge(u, v, f, c), ids.emplace_back(v, id);
    else
      id = mf.addedge(v, u, f, -c), val += f * c, d[u] -= f, d[v] += f,
         ids.emplace_back(v, mf.g[u][id].rid);
  }
  auto flow(int s, int t, Cap lim = numeric_limits<Cap>::max()) {
    int s1 = n, t1 = n + 1;
    for (int i = 0; i < n; i++) {
      if (d[i] > 0)
        mf.addedge(s1, i, d[i], 0);
      else if (d[i] < 0)
        mf.addedge(i, t1, -d[i], 0);
    }
    mf.addedge(t, s, lim, 0);
    auto ret = mf.flow(s1, t1);
    cap = mf.g[s].back().cap, val += ret.cst;
    mf.g[s].pop_back(), mf.g[t].pop_back();
    ret = mf.template flow<true>(s, t, lim - cap);
    ret.cap += cap, ret.cst += val;
    return ret;
  }
  auto sch() {
    vector<tuple<int, int, Cap, int>> vec;
    //  for (auto [v, id] : ids) 
    for (int i = 0; i < (int)ids.size(); i++) {
      auto [v, id] = ids[i];
      auto e = mf.g[v][id];
      vec.emplace_back(e.v, mf.g[e.v][e.rid].v, e.cap, i);
    }
    return vec;
  }
}; 
int n1, n2, m, col[6010], n;
int main() {
#ifndef LOCAL
#ifdef NF
  freopen("b.in", "r", stdin);
  freopen("b.out", "w", stdout);
#endif
  cin.tie(nullptr)->sync_with_stdio(false);
#endif
  cin >> n1 >> n2 >> m, n = n1 + n2;
  mcf_interface<int, int> mf(n1 + n2 + 2);
  vector<pair<int, int>> fuck;
  for (int i = 1, u, v; i <= m; i++) {
    cin >> u >> v;
    if (u > v) swap(u, v);
    fuck.emplace_back(u, v);
      col[u] ^= 1, col[v] ^= 1;
  }
  for (auto [u, v] : fuck) {
    if (col[u] != col[v]) swap(u, v);
    debug("u = %d, v = %d\n", u, v);
    mf.addedge(u, v, 1, -1);
  }
  for (int i = 1; i <= n1; i++) mf.addedge(0, i, 1, 0);
  for (int i = n1 + 1; i <= n1 + n2; i++) mf.addedge(i, n1 + n2 + 1, 1, 0);
  int rcnt = -mf.flow(0, n1 + n2 + 1).cst;
  cout << rcnt << endl;
  auto sch = mf.sch();
  for (int i = 0; i < (int)sch.size();) {
    if (!get<2>(sch[i]) || get<0>(sch[i]) == 0 || get<1>(sch[i]) == n1 + n2 + 1)
      swap(sch[i], sch.back()), sch.pop_back();
    else
      i++;
  }
  for (auto [u, v, cap, id] : sch) debug("(%d, %d, %d, %d)\n", u, v, cap, id);
  assert((int)sch.size() == rcnt);
  vector<int> answer;
  struct edge {
    int u, v, id;
  };
  static vector<edge> g[6010];
  while (!sch.empty()) {
    static int dfn[6010], low[6010], cnt, stk[6010], top, col[6010];
    static edge* fa[6010];
    memset(dfn, 0, sizeof dfn);
    memset(col, 0, sizeof col);
    for (int i = 1; i <= n; i++) g[i].clear();
    for (auto [u, v, cap, id] : sch) g[u].push_back({u, v, id});
    top = cnt = 0;
    vector<int> cyc;
    auto tarjan = [&](auto self, int u) -> void {
      dfn[u] = low[u] = ++cnt, stk[++top] = u;
      for (auto e : g[u]) {
        if (!cyc.empty()) break;
        int v = e.v;
        if (!dfn[v]) fa[v] = &e, self(self, v), low[u] = min(low[u], low[v]);
        else if (!col[v]) {
          low[u] = min(low[u], dfn[v]);
          vector<edge> tmp;
          tmp.push_back(e);
          for (int x = u; x != v; x = fa[x]->u) tmp.push_back(*fa[x]);
          for (auto e : tmp) cyc.push_back(e.id), debug("%d ", e.id);
          debug("\n");
          for (auto e : tmp) if (::col[e.u] == ::col[e.v]) answer.push_back(e.id);
          for (auto e : tmp) if (::col[e.u] != ::col[e.v]) answer.push_back(e.id);
          break;
        }
      }
      if (low[u] == dfn[u]) {
        col[u] = 1341234;
        do col[stk[top]] = 123124; while (stk[top--] != u);
      }
    };
    for (int i = 1; i <= n; i++) if (!dfn[i]) tarjan(tarjan, i);
    if (cyc.empty()) break;
    sort(cyc.begin(), cyc.end());
    auto tmp = exchange(sch, {});
    for (auto e : tmp) {
      if (!binary_search(cyc.begin(), cyc.end(), get<3>(e))) sch.push_back(e);
    }
  }
  int deg[6010];
  memset(deg, 0, sizeof deg);
  for (auto [u, v, cap, id] : sch) deg[v] += 1;
  int res = (int)sch.size();
  while (res > 0) {
    int u = min_element(deg + 1, deg + n + 1) - deg;
    for (int i = 1; i <= n; i++) if (!deg[i] && !g[i].empty()) u = i;
    assert(deg[u] == 0);
    vector<edge> tmp;
    while (!g[u].empty()) tmp.push_back(g[u].back()), g[u].pop_back(), u = tmp.back().v, deg[u] -= 1;
    res -= (int)tmp.size();
    for (auto e : tmp) if (col[e.u] == col[e.v]) answer.push_back(e.id);
    for (auto e : tmp) if (col[e.u] != col[e.v]) answer.push_back(e.id);
  }
  for (int x : answer) cout << x + 1 << " ";
  cout << endl;
  return 0;
}