#include <bits/stdc++.h>
using namespace std;
struct BiconnectedComponents {
  int n, timer = 0;
  vector<vector<int>> g;
  vector<int> in, low, was;
  stack<pair<int, int>> s;
  BiconnectedComponents(const vector<vector<int>>& g)
      : n(g.size()), g(g), in(n), low(n), was(n) {}
  vector<vector<pair<int, int>>> get() {
    vector<vector<pair<int, int>>> r;
    for (int i = 0; i < n; ++i) {
      if (!was[i]) {
        dfs(i, r);
      }
    }
    return r;
  }
  void dfs(int v, vector<vector<pair<int, int>>>& r, int parent = -1) {
    was[v] = 1;
    in[v] = low[v] = timer++;
    for (int to : g[v]) {
      auto edge = make_pair(v, to);
      if (!was[to]) {
        s.push(edge);
        dfs(to, r, v);
        low[v] = min(low[v], low[to]);
        if (parent == -1 || low[to] >= in[v]) {
          vector<pair<int, int>> component;
          while (true) {
            component.push_back(s.top());
            s.pop();
            if (component.back() == edge) {
              break;
            }
          }
          r.push_back(component);
        }
      } else if (to != parent) {
        low[v] = min(low[v], in[to]);
        if (in[to] < in[v]) {
          s.push(edge);
        }
      }
    }
  }
};
struct TreeQueries {
  int n, timer = 0, lg = 0;
  vector<vector<int>> g, lca;
  vector<int> in, out;
  vector<int> depth;
  TreeQueries(const vector<vector<int>>& g)
      : n(g.size()), g(g), lca(n), in(n), out(n), depth(n) {
    while ((1 << lg) <= n) {
      ++lg;
    }
    for (int i = 0; i < n; ++i) lca[i].resize(lg);
    dfs(0, 0);
  }
  void dfs(int v, int parent) {
    in[v] = timer++;
    lca[v][0] = parent;
    for (int i = 1; i < lg; ++i) lca[v][i] = lca[lca[v][i - 1]][i - 1];
    for (int to : g[v]) {
      if (to == parent) continue;
      depth[to] = depth[v] + 1;
      dfs(to, v);
    }
    out[v] = timer++;
  }
  int is_ancestor(int x, int y) { return in[x] <= in[y] && out[x] >= out[y]; }
  int getLca(int x, int y) {
    if (is_ancestor(x, y)) return x;
    if (is_ancestor(y, x)) return y;
    for (int i = lg - 1; i >= 0; --i)
      if (!is_ancestor(lca[x][i], y)) x = lca[x][i];
    return lca[x][0];
  }
  int getPathLength(int x, int y) {
    return depth[x] + depth[y] - 2 * depth[getLca(x, y)] + 1;
  }
};
int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  int n, m, q;
  cin >> n >> m >> q;
  vector<vector<int>> g(n);
  for (int i = 0; i < m; ++i) {
    int x, y;
    cin >> x >> y;
    --x;
    --y;
    g[x].push_back(y);
    g[y].push_back(x);
  }
  auto components = BiconnectedComponents(g).get();
  int c = (int)components.size();
  vector<vector<int>> gr(n + c);
  for (int i = 0; i < c; ++i) {
    auto component = components[i];
    vector<int> vertices;
    for (auto& edge : component) {
      vertices.push_back(edge.first);
      vertices.push_back(edge.second);
    }
    sort(vertices.begin(), vertices.end());
    vertices.erase(unique(vertices.begin(), vertices.end()), vertices.end());
    for (int v : vertices) {
      gr[v].push_back(n + i);
      gr[n + i].push_back(v);
    }
  }
  auto tree = TreeQueries(gr);
  for (int i = 0; i < q; ++i) {
    int x, y;
    cin >> x >> y;
    --x;
    --y;
    cout << (tree.getPathLength(x, y) - 1) / 2 << '\n';
  }
}
