#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int arr = 2e5 + 10;
const int ar = 2e3 + 10;
const long double pi = acos(-1);
const long double eps = 1e-10;
const long long md = 1e9 + 7;
struct solver {
  const int M = 22;
  int n;
  vector<vector<int>> reb;
  vector<vector<int>> pred;
  vector<int> d;
  solver() {
    n = 0;
    reb.clear();
    pred.clear();
    d.clear();
  }
  solver(int n) {
    this->n = n;
    reb.assign(n, {});
    pred.assign(n, vector<int>(M, 0));
    d.assign(n, 0);
  }
  void add_edge(int u, int v) {
    reb[u].push_back(v);
    reb[v].push_back(u);
  }
  void dfs(int now, int p) {
    pred[now][0] = p;
    for (int i = 1; i < M; i++) {
      pred[now][i] = pred[pred[now][i - 1]][i - 1];
    }
    for (auto wh : reb[now]) {
      if (wh != p) {
        d[wh] = d[now] + 1;
        dfs(wh, now);
      }
    }
  }
  void build() { dfs(0, 0); }
  int lca(int u, int v) {
    if (d[u] > d[v]) {
      swap(u, v);
    }
    for (int i = M - 1; i >= 0; i--) {
      if (d[pred[v][i]] >= d[u]) {
        v = pred[v][i];
      }
    }
    if (u == v) {
      return u;
    }
    for (int i = M - 1; i >= 0; i--) {
      if (pred[u][i] != pred[v][i]) {
        u = pred[u][i];
        v = pred[v][i];
      }
    }
    return pred[u][0];
  }
  int dist(int u, int v) { return d[u] + d[v] - 2 * d[lca(u, v)]; }
};
vector<int> reb[arr];
bool bad[arr];
vector<vector<int>> comps;
map<pair<int, int>, int> used_edge;
map<pair<int, int>, bool> have_in_start_graph;
bool use_edge(int u, int v) {
  if (u > v) {
    swap(u, v);
  }
  return used_edge[{u, v}];
}
void set_use_edge(int u, int v) {
  if (u > v) {
    swap(u, v);
  }
  used_edge[{u, v}] = 1;
}
int timer = 0;
bool use[arr];
int tin[arr];
int tup[arr];
set<pair<int, int>> s;
void dfs(int now, int pred) {
  use[now] = 1;
  tin[now] = timer++;
  tup[now] = tin[now];
  int cnt_go = 0;
  for (auto wh : reb[now]) {
    if (wh == pred) {
      continue;
    }
    if (use[wh]) {
      tup[now] = min(tup[now], tin[wh]);
    } else {
      cnt_go++;
      dfs(wh, now);
      tup[now] = min(tup[now], tup[wh]);
      if (tup[wh] >= tin[now]) {
        if (now != pred) {
          bad[now] = 1;
        }
        vector<int> cur_comp;
        while (!s.empty() && s.rbegin()->first >= tin[wh]) {
          auto kek = *s.rbegin();
          s.erase(kek);
          cur_comp.push_back(kek.second);
        }
        cur_comp.push_back(now);
        comps.push_back(cur_comp);
      }
    }
  }
  s.insert(make_pair(tin[now], now));
  if (now == pred && cnt_go > 1) {
    bad[now] = 1;
  }
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  ;
  int n, m, q;
  cin >> n >> m >> q;
  for (int i = 1; i <= m; i++) {
    int u, v;
    cin >> u >> v;
    u--;
    v--;
    reb[u].push_back(v);
    reb[v].push_back(u);
  }
  int last = n;
  if (n * (n - 1) / 2 != m) {
    dfs(1, 1);
    solver S(n + (int)(comps.size()));
    for (auto i : comps) {
      for (auto j : i) {
        S.add_edge(j, last);
      }
      last++;
    }
    S.build();
    while (q--) {
      int a, b;
      cin >> a >> b;
      a--;
      b--;
      cout << S.dist(a, b) / 2 << "\n";
    }
  } else {
    while (q--) {
      cout << 1 << "\n";
    }
  }
}
