#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
vector<int> g[N];
vector<int> tree[2 * N];
class LCA {
 public:
  int n, ln;
  vector<vector<int>> parent;
  vector<int> depth;
  LCA(int _n, int root = -1) : n(_n), depth(_n) {
    ln = 0;
    while (n >= (1 << ln)) ln++;
    parent = vector<vector<int>>(ln, vector<int>(n));
    if (root != -1) init(root);
  }
  void dfs(const int v, const int p, const int d) {
    parent[0][v] = p;
    depth[v] = d;
    for (auto to : tree[v])
      if (to != p) dfs(to, v, d + 1);
  }
  void init(const int root) {
    dfs(root, -1, 0);
    for (int k = 0; k + 1 < ln; k++) {
      for (int v = 0; v < n; v++) {
        if (parent[k][v] < 0)
          parent[k + 1][v] = -1;
        else
          parent[k + 1][v] = parent[k][parent[k][v]];
      }
    }
  }
  int query(int u, int v) const {
    if (depth[u] > depth[v]) swap(u, v);
    for (int k = 0; k < ln; k++) {
      if ((depth[v] - depth[u]) >> k & 1) v = parent[k][v];
    }
    if (u == v) return u;
    for (int k = ln - 1; k >= 0; k--) {
      if (parent[k][u] != parent[k][v]) {
        u = parent[k][u];
        v = parent[k][v];
      }
    }
    return parent[0][u];
  }
};
bool visited[N];
int v_ord[N], v_num[N];
int visited_num = 0;
int n;
set<pair<int, int>> edges;
int dfs(int v) {
  v_ord[v] = visited_num++;
  visited[v] = true;
  int ret = 123456789;
  for (auto to : g[v]) {
    if (visited[to]) {
      if (v_ord[to] < v_ord[v]) {
        ret = min(ret, v_ord[to]);
        v_num[v_ord[to]] = max(v_num[v_ord[to]], v_ord[v]);
      }
    } else {
      int r = dfs(to);
      if (r == v_ord[v]) {
        edges.insert({v, n + v_num[r]});
      } else {
        ret = min(ret, r);
      }
    }
  }
  if (ret < 123456789) {
    edges.insert({v, n + v_num[ret]});
  }
  return ret;
}
int main() {
  int m, q;
  scanf("%d %d %d", &n, &m, &q);
  for (int i = (int)(0); i < (int)(m); i++) {
    int a, b;
    scanf("%d %d", &a, &b);
    a--;
    b--;
    g[a].push_back(b);
    g[b].push_back(a);
  }
  fill(visited, visited + n, false);
  dfs(0);
  for (auto &p : edges) {
    int a = p.first, b = p.second;
    tree[a].push_back(b);
    tree[b].push_back(a);
  }
  LCA lca(2 * n, 0);
  for (int _ = (int)(0); _ < (int)(q); _++) {
    int a, b;
    scanf("%d %d", &a, &b);
    a--;
    b--;
    int par = lca.query(a, b);
    int ans = lca.depth[a] + lca.depth[b] - 2 * lca.depth[par];
    printf("%d\n", ans / 2);
  }
  return 0;
}
