#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9) + 7;
const long long LL_INF = 1ll * INF * INF;
const int MAX_N = 200000 + 7;
const int multipleTest = 0;
const double pi = acos(-1);
template <typename T>
inline void addmod(T& a, const long long& b, const int MOD = INF) {
  (a += b) %= MOD;
  if (a < 0) a += MOD;
}
int n, m, q;
vector<int> originAdj[MAX_N];
set<pair<int, int> > cycleEdges;
int parent[MAX_N];
vector<pair<int, int> > adj[MAX_N];
vector<pair<int, int> > edges;
int lt[MAX_N];
int added;
bool connected(int u, int v) {
  if (u > v) swap(u, v);
  auto it = std::lower_bound(edges.begin(), edges.end(), make_pair(u, v));
  return it != edges.end() && (*it) == make_pair(u, v);
}
bool sameGroup(int u, int v) {
  if (u > v) swap(u, v);
  return cycleEdges.find({u, v}) != cycleEdges.end();
}
inline void addEdge(int u, int v, int c) {
  adj[u].push_back({v, c});
  adj[v].push_back({u, c});
}
void dfs(int u) {
  for (int& v : originAdj[u])
    if (parent[v] == 0) {
      parent[v] = u;
      dfs(v);
    } else {
      if (v == parent[u] || sameGroup(u, v)) continue;
      vector<int> group = {v};
      int temp = u;
      while (temp != v) {
        group.push_back(temp);
        temp = parent[temp];
      }
      for (int& c : originAdj[u])
        if (connected(c, v)) {
          group.push_back(c);
        }
      sort(group.begin(), group.end());
      group.resize(std::unique(group.begin(), group.end()) - group.begin());
      ++added;
      for (int i = 0, m = (int)(group).size(); i < m; ++i) {
        addEdge(added, group[i], 1);
        for (int j = 0; j < i; ++j) {
          cycleEdges.insert({group[j], group[i]});
        }
      }
    }
}
void addEdge(int u, int v) { originAdj[u].push_back(v); }
const int LOG_N = 18;
int height[MAX_N];
int dist[MAX_N];
int lca[MAX_N][LOG_N];
void buildLCA(int u, int r) {
  height[u] = (r == -1) ? 0 : height[r] + 1;
  lca[u][0] = r;
  for (int j = (1), _b = (LOG_N); j < _b; ++j)
    if (lca[u][j - 1] == -1)
      lca[u][j] = -1;
    else
      lca[u][j] = lca[lca[u][j - 1]][j - 1];
  for (auto& edge : adj[u]) {
    int v = edge.first;
    if (v != r) {
      dist[v] = dist[u] + edge.second;
      buildLCA(v, u);
    }
  }
}
int getLcaRoot(int u, int v) {
  if (height[u] < height[v]) swap(u, v);
  while (height[u] > height[v]) {
    int heightLog = lt[height[u] - height[v]];
    u = lca[u][heightLog];
  }
  if (u == v) return u;
  for (int j = LOG_N - 1; j >= 0; --j) {
    if (lca[u][j] != -1 && lca[u][j] != lca[v][j]) {
      u = lca[u][j];
      v = lca[v][j];
    }
  }
  return lca[u][0];
}
void solve() {
  for (int i = 1, last = 0; i < MAX_N; ++i) {
    if (i == (1 << last)) {
      lt[i] = last;
      last++;
    } else
      lt[i] = lt[i - 1];
  }
  cin >> n >> m >> q;
  added = n;
  edges.resize(m);
  for (int i = (0), _b = (m); i < _b; ++i) {
    int u, v;
    cin >> u >> v;
    if (u > v) swap(u, v);
    addEdge(u, v);
    addEdge(v, u);
    edges[i] = {u, v};
  }
  sort(edges.begin(), edges.end());
  parent[1] = -1;
  dfs(1);
  for (int u = 1; u <= n; ++u) {
    for (const int& v : originAdj[u])
      if (!sameGroup(u, v)) {
        adj[u].push_back({v, 2});
      }
  }
  buildLCA(1, -1);
  for (int t = (0), _b = (q); t < _b; ++t) {
    int u, v;
    cin >> u >> v;
    int r = getLcaRoot(u, v);
    int ans = (dist[u] + dist[v] - 2 * dist[r]) >> 1;
    cout << ans << '\n';
  }
}
int main() {
  ios_base::sync_with_stdio(0), cin.tie(0);
  int Test = 1;
  if (multipleTest) cin >> Test;
  for (int i = 0; i < Test; ++i) {
    solve();
  }
}
