#include <bits/stdc++.h>
using namespace std;
const int N = 600010, LOG = 22;
int dfs_low[N], dfs_num[N], dfs_cnt, sum[N], dp[LOG][N], depth[N], u, v, q, l,
    n, m;
vector<int> g[N];
vector<pair<int, int> > T[N];
stack<int> st;
bool vis[N];
void DFS(int node, int prnt) {
  dfs_low[node] = dfs_num[node] = dfs_cnt++;
  st.push(node);
  vis[node] = true;
  for (int i = 0; i < g[node].size(); i++) {
    if (g[node][i] == prnt) continue;
    if (vis[g[node][i]]) {
      dfs_low[node] = min(dfs_low[node], dfs_num[g[node][i]]);
      continue;
    }
    DFS(g[node][i], node);
    dfs_low[node] = min(dfs_low[node], dfs_low[g[node][i]]);
    if (dfs_low[g[node][i]] > dfs_num[node]) {
      T[g[node][i]].push_back(make_pair(node, 2));
      T[node].push_back(make_pair(g[node][i], 2));
    } else if (dfs_low[g[node][i]] == dfs_num[node]) {
      n++;
      T[n].push_back(make_pair(node, 1));
      T[node].push_back(make_pair(n, 1));
      while (dfs_low[st.top()] >= dfs_num[node] && st.top() != node) {
        T[n].push_back(make_pair(st.top(), 1));
        T[st.top()].push_back(make_pair(n, 1));
        st.pop();
      }
    }
  }
  if (dfs_low[node] == dfs_num[node]) st.pop();
}
void DFS2(int node) {
  for (int i = 0; i < (int)T[node].size(); i++) {
    if (T[node][i].first != dp[0][node]) {
      dp[0][T[node][i].first] = node;
      depth[T[node][i].first] = depth[node] + 1;
      sum[T[node][i].first] = sum[node] + T[node][i].second;
      DFS2(T[node][i].first);
    }
  }
}
int LCA(int u, int v) {
  if (depth[u] > depth[v]) swap(u, v);
  for (int k = LOG - 1; k >= 0; k--) {
    if (depth[v] - (1 << k) >= depth[u]) {
      v = dp[k][v];
    }
  }
  if (u == v) return u;
  for (int k = LOG - 1; k >= 0; k--) {
    if (dp[k][u] != dp[k][v]) {
      v = dp[k][v];
      u = dp[k][u];
    }
  }
  return dp[0][u];
}
int main() {
  scanf("%d%d%d", &n, &m, &q);
  for (int i = 0; i < m; i++) {
    scanf("%d%d", &u, &v);
    g[u].push_back(v);
    g[v].push_back(u);
  }
  DFS(1, -1);
  dp[0][1] = -1;
  depth[1] = sum[1] = 0;
  DFS2(1);
  for (int k = 1; k < LOG; k++) {
    for (int i = 1; i <= n; i++) {
      if (dp[k - 1][i] == -1)
        dp[k][i] = -1;
      else
        dp[k][i] = dp[k - 1][dp[k - 1][i]];
    }
  }
  while (q--) {
    scanf("%d%d", &u, &v);
    l = LCA(u, v);
    printf("%d\n", (sum[u] + sum[v] - sum[l] - sum[l]) / 2);
  }
  return 0;
}
