#include <bits/stdc++.h>
#pragma GCC optimize(4)
using namespace std;
namespace debug {
void err() { cout << endl; }
template <template <typename...> class T, typename t, typename... Args>
void err(T<t> a, Args... args) {
  for (auto x : a) cout << x << ' ';
  err(args...);
}
template <typename T, typename... Args>
void err(T a, Args... args) {
  cout << a << ' ';
  err(args...);
}
}  // namespace debug
namespace stdio_input {
void scanf_int() {}
template <typename T, typename... Args>
void scanf_int(T &a, Args &...args) {
  scanf("%d", &a);
  scanf_int(args...);
}
void scanf_ll() {}
template <typename T, typename... Args>
void scanf_ll(T &a, Args &...args) {
  scanf("%lld", &a);
  scanf_ll(args...);
}
void scanf_double() {}
template <typename T, typename... Args>
void scanf_double(T &a, Args &...args) {
  scanf("%lf", &a);
  scanf_double(args...);
}
}  // namespace stdio_input
namespace const_var {
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const double PI = acos(-1.0);
const long double eps = 1e-6;
const int mod = 1e9 + 7;
const int maxn = 3e6;
const int N = 2e5 + 10;
const int M = 1e6 + 10;
}  // namespace const_var
using namespace debug;
using namespace stdio_input;
using namespace const_var;
int T = 0;
void testcase() { cout << "Case #" << (++T) << ": "; }
struct Edge {
  int to, next;
} edge[M];
std::vector<int> G[N];
int Low[N], DFN[N], Stack[N], head[N], Instack[N];
int Index, top, n1, cnt;
void addedge(int u, int v) {
  edge[cnt].to = v;
  edge[cnt].next = head[u];
  head[u] = cnt++;
}
void Tarjan(int u, int pre) {
  int v;
  Low[u] = DFN[u] = ++Index;
  Stack[top++] = u;
  Instack[u] = true;
  for (int i = head[u]; ~i; i = edge[i].next) {
    v = edge[i].to;
    if (v == pre) continue;
    if (!DFN[v]) {
      Tarjan(v, u);
      if (Low[u] > Low[v]) Low[u] = Low[v];
      if (Low[v] >= DFN[u]) {
        int vn;
        ++n1;
        G[n1].push_back(u);
        G[u].push_back(n1);
        do {
          vn = Stack[--top];
          Instack[vn] = false;
          G[vn].push_back(n1);
          G[n1].push_back(vn);
        } while (vn != v);
      }
    } else if (Instack[v] && Low[u] > DFN[v])
      Low[u] = DFN[v];
  }
}
const int DEG = 21;
int fa[N][DEG], dep[N];
void dfs(int u, int pre) {
  fa[u][0] = pre;
  dep[u] = dep[pre] + 1;
  for (int i = 1; i <= DEG - 1; ++i) {
    fa[u][i] = fa[fa[u][i - 1]][i - 1];
  }
  for (auto v : G[u]) {
    if (v == pre) continue;
    dfs(v, u);
  }
}
int LCA(int u, int v) {
  if (dep[u] < dep[v]) swap(u, v);
  int t = dep[u] - dep[v];
  for (int i = 0; i < DEG; ++i) {
    if (t & (1 << i)) u = fa[u][i];
  }
  for (int i = DEG - 1; i >= 0; --i) {
    int uu = fa[u][i], vv = fa[v][i];
    if (uu != vv) {
      u = uu;
      v = vv;
    }
  }
  return u == v ? u : fa[u][0];
}
void work() {
  int n, m, q;
  cin >> n >> m >> q;
  for (int i = 1; i <= n; ++i) {
    head[i] = -1;
  }
  n1 = n;
  for (int i = 0; i < m; ++i) {
    int u, v;
    cin >> u >> v;
    addedge(u, v);
    addedge(v, u);
  }
  for (int i = 1; i <= n; ++i) {
    if (!DFN[i]) {
      Tarjan(i, i);
    }
  }
  dfs(1, 1);
  for (; q--;) {
    int u, v;
    cin >> u >> v;
    int lca = LCA(u, v);
    int ans = dep[u] + dep[v] - 2 * dep[lca];
    ans >>= 1;
    cout << ans << endl;
  }
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  work();
  return 0;
}
