#include <bits/stdc++.h>
using namespace std;
namespace whatever {
int readu() {
  char ch = getchar();
  while (!isdigit(ch)) ch = getchar();
  int value = ch - '0';
  ch = getchar();
  while (isdigit(ch)) {
    value = value * 10 + ch - '0';
    ch = getchar();
  }
  return value;
}
void writeu(int n) {
  if (n < 10)
    putchar(n + '0');
  else {
    writeu(n / 10);
    putchar(n % 10 + '0');
  }
}
namespace tree {
vector<int> tree_adj[100001 + 100000];
int size[100001 + 100000];
int heavy[100001 + 100000];
int depth[100001 + 100000];
int father[100001 + 100000];
void dfs1(int cur) {
  size[cur] = 1;
  for (auto to : tree_adj[cur])
    if (to != father[cur]) {
      depth[to] = depth[cur] + 1;
      father[to] = cur;
      dfs1(to);
      size[cur] += size[to];
      if (size[heavy[cur]] < size[to]) heavy[cur] = to;
    }
}
int top[100001 + 100000];
void dfs2(int cur) {
  for (auto to : tree_adj[cur])
    if (to != father[cur]) {
      top[to] = (to == heavy[cur] ? top[cur] : to);
      dfs2(to);
    }
}
int lca(int a, int b) {
  while (top[a] != top[b]) {
    if (depth[top[a]] > depth[top[b]])
      a = father[top[a]];
    else
      b = father[top[b]];
  }
  return (depth[a] < depth[b] ? a : b);
}
}  // namespace tree
namespace graph {
vector<int> adj[100001];
int dfn[100001];
int low[100001];
int dfs_time;
int stack[100001];
int top;
int bcc_cnt;
void dfs(int cur) {
  dfn[cur] = low[cur] = ++dfs_time;
  stack[top++] = cur;
  for (auto to : adj[cur]) {
    if (!dfn[to]) {
      dfs(to);
      low[cur] = min(low[cur], low[to]);
      if (low[to] == dfn[cur]) {
        ++bcc_cnt;
        do {
          --top;
          tree::tree_adj[stack[top]].push_back(100000 + bcc_cnt);
          tree::tree_adj[100000 + bcc_cnt].push_back(stack[top]);
        } while (stack[top] != to);
        tree::tree_adj[cur].push_back(100000 + bcc_cnt);
        tree::tree_adj[100000 + bcc_cnt].push_back(cur);
      }
    } else
      low[cur] = min(low[cur], dfn[to]);
  }
}
}  // namespace graph
void run() {
  int n = readu();
  int m = readu();
  int q = readu();
  while (--m != -1) {
    int u = readu();
    int v = readu();
    graph::adj[u].push_back(v);
    graph::adj[v].push_back(u);
  }
  graph::dfs(1);
  assert(graph::top == 1);
  assert(graph::stack[0] == 1);
  tree::dfs1(1);
  assert(tree::size[1] == graph::bcc_cnt + n);
  tree::dfs2(1);
  while (--q != -1) {
    int a = readu();
    int b = readu();
    int l = tree::lca(a, b);
    int dis = tree::depth[a] - tree::depth[l] + tree::depth[b] - tree::depth[l];
    assert(dis % 2 == 0);
    writeu(dis / 2);
    putchar('\n');
  }
}
}  // namespace whatever
int main() { whatever::run(); }
