#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFLL = 0x3f3f3f3f3f3f3f3fLL;
const int mod = 1e9 + 7;
const int MX = 2e5 + 5;
struct Edge {
  int u, v, w, nxt;
} E[MX * 5];
int head[MX], rear;
void edge_add(int u, int v, int w = 0) {
  E[rear] = Edge{u, v, w, head[u]};
  head[u] = rear++;
}
void init() {
  memset(head, -1, sizeof(head));
  rear = 0;
}
namespace BCC {
struct edge {
  int u, v;
  edge(int u, int v) : u(u), v(v) {}
};
stack<edge> s;
struct Edge {
  int v, nxt;
} E[MX * 5];
int n, m;
int tot, head[MX];
int pre[MX];
int dfs_clock;
int iscut[MX];
int bcc_cnt;
int bccno[MX];
vector<int> bcc[MX];
void edge_add(int u, int v) {
  E[tot] = Edge{v, head[u]};
  head[u] = tot++;
}
void init(int n) {
  for (int i = 1; i <= n; i++) {
    pre[i] = iscut[i] = bccno[i] = 0;
    head[i] = -1;
  }
  tot = dfs_clock = bcc_cnt = 0;
}
int dfs(int u, int fa) {
  int lowu = pre[u] = ++dfs_clock;
  int child = 0;
  for (int i = head[u]; ~i; i = E[i].nxt) {
    int v = E[i].v;
    edge e = (edge){u, v};
    if (!pre[v]) {
      s.push(e);
      child++;
      int lowv = dfs(v, u);
      lowu = min(lowu, lowv);
      if (lowv >= pre[u]) {
        iscut[u] = 1;
        bcc_cnt++;
        bcc[bcc_cnt].clear();
        while (1) {
          edge first = s.top();
          s.pop();
          if (bccno[first.u] != bcc_cnt) {
            bcc[bcc_cnt].push_back(first.u);
            bccno[first.u] = bcc_cnt;
          }
          if (bccno[first.v] != bcc_cnt) {
            bcc[bcc_cnt].push_back(first.v);
            bccno[first.v] = bcc_cnt;
          }
          if (first.u == u && first.v == v) break;
        }
      }
    } else if (pre[v] < pre[u] && v != fa) {
      s.push(e);
      lowu = min(lowu, pre[v]);
    }
  }
  if (fa < 0 && child == 1) iscut[u] = 0;
  return lowu;
}
}  // namespace BCC
int par[MX * 2];
int find(int first) {
  return par[first] == first ? first : (par[first] = find(par[first]));
}
void rebuild(int n, int m, pair<int, int> Edge[]) {
  init();
  int cnt = BCC::bcc_cnt;
  for (int i = 1; i < (n + cnt + 1); ++i) par[i] = i;
  for (int i = 1; i < (cnt + 1); ++i)
    for (int j = 0; j < (BCC::bcc[i].size()); ++j) {
      edge_add(BCC::bcc[i][j], n + i, 1);
      edge_add(n + i, BCC::bcc[i][j], 1);
      if (j) {
        int p1 = find(BCC::bcc[i][j]), p2 = find(BCC::bcc[i][j - 1]);
        if (p1 != p2) par[p1] = p2;
      }
    }
  for (int i = 0; i < (m); ++i) {
    int u = Edge[i].first, v = Edge[i].second;
    int p1 = find(u), p2 = find(v);
    if (p1 != p2) {
      par[p1] = p2;
      edge_add(u, v, 2);
      edge_add(v, u, 2);
    }
  }
}
namespace LCA {
int sz, ver[2 * MX], deep[2 * MX], fir[MX], dp[2 * MX][30], vis[MX], dir[MX];
void init(int n) {
  for (int i = 0; i <= n; i++) dir[i] = vis[i] = 0;
  sz = 0;
}
void dfs(int u, int dep) {
  vis[u] = 1;
  ver[++sz] = u;
  fir[u] = sz;
  deep[sz] = dep;
  for (int i = head[u]; ~i; i = E[i].nxt) {
    if (vis[E[i].v]) continue;
    int v = E[i].v;
    dir[v] = dir[u] + E[i].w;
    dfs(v, dep + 1);
    ver[++sz] = u;
    deep[sz] = dep;
  }
}
void ST(int n) {
  for (int i = 1; i <= n; i++) dp[i][0] = i;
  for (int j = 1; (1 << j) <= n; j++) {
    for (int i = 1; i + (1 << j) - 1 <= n; i++) {
      int a = dp[i][j - 1], b = dp[i + (1 << (j - 1))][j - 1];
      dp[i][j] = deep[a] < deep[b] ? a : b;
    }
  }
}
int RMQ(int l, int r) {
  int k = 0;
  while ((1 << (k + 1)) <= r - l + 1) k++;
  int a = dp[l][k], b = dp[r - (1 << k) + 1][k];
  return deep[a] < deep[b] ? a : b;
}
int LCA(int u, int v) {
  int first = fir[u], second = fir[v];
  if (first > second) swap(first, second);
  int ret = RMQ(first, second);
  return ver[ret];
}
void pre_solve(int n) {
  init(n);
  dir[1] = 1;
  dfs(1, 1);
  ST(sz);
}
int get_dis(int u, int v) { return dir[u] + dir[v] - 2 * dir[LCA(u, v)]; }
}  // namespace LCA
pair<int, int> p[MX * 5];
int main() {
  int n, m, q;
  cin >> n >> m >> q;
  int u, v;
  BCC::init(n);
  for (int i = 0; i < (m); ++i) {
    scanf("%d%d", &u, &v);
    p[i] = pair<int, int>(u, v);
    BCC::edge_add(u, v);
    BCC::edge_add(v, u);
  }
  BCC::dfs(1, -1);
  rebuild(n, m, p);
  LCA::pre_solve(n + BCC::bcc_cnt);
  for (int i = 0; i < (q); ++i) {
    scanf("%d%d", &u, &v);
    printf("%d\n", LCA::get_dis(u, v) / 2);
  }
  return 0;
}
