#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const long long LINF = 2e16;
const int magic = 348;
const int MOD = 1e9 + 7;
const double eps = 1e-10;
const double pi = acos(-1);
struct fastio {
  static const int S = 1e7;
  char rbuf[S + 48], wbuf[S + 48];
  int rpos, wpos, len;
  fastio() { rpos = len = wpos = 0; }
  inline char Getchar() {
    if (rpos == len) rpos = 0, len = fread(rbuf, 1, S, stdin);
    if (!len) return EOF;
    return rbuf[rpos++];
  }
  template <class T>
  inline void Get(T &first) {
    char ch;
    bool f;
    T res;
    while (!isdigit(ch = Getchar()) && ch != '-') {
    }
    if (ch == '-')
      f = false, res = 0;
    else
      f = true, res = ch - '0';
    while (isdigit(ch = Getchar())) res = res * 10 + ch - '0';
    first = (f ? res : -res);
  }
  inline void getstring(char *s) {
    char ch;
    while ((ch = Getchar()) <= 32) {
    }
    for (; ch > 32; ch = Getchar()) *s++ = ch;
    *s = '\0';
  }
  inline void flush() {
    fwrite(wbuf, 1, wpos, stdout);
    fflush(stdout);
    wpos = 0;
  }
  inline void Writechar(char ch) {
    if (wpos == S) flush();
    wbuf[wpos++] = ch;
  }
  template <class T>
  inline void Print(T first, char ch) {
    char s[20];
    int pt = 0;
    if (first == 0)
      s[++pt] = '0';
    else {
      if (first < 0) Writechar('-'), first = -first;
      while (first) s[++pt] = '0' + first % 10, first /= 10;
    }
    while (pt) Writechar(s[pt--]);
    Writechar(ch);
  }
  inline void printstring(char *s) {
    int pt = 1;
    while (s[pt] != '\0') Writechar(s[pt++]);
  }
} io;
template <typename T>
inline void check_max(T &first, T cmp) {
  first = max(first, cmp);
}
template <typename T>
inline void check_min(T &first, T cmp) {
  first = min(first, cmp);
}
template <typename T>
inline T myabs(T first) {
  return first >= 0 ? first : -first;
}
const int MAXN = 1e6;
struct Edge {
  int first, second;
  inline void input() {
    io.Get(first);
    io.Get(second);
  }
} edge[MAXN + 48];
vector<int> v[MAXN + 48];
vector<pair<int, int> > vv[MAXN + 48];
int n, m, q;
int dfn[MAXN + 48], low[MAXN + 48], Index, ind;
stack<int> s;
vector<int> cir;
int val[MAXN + 48];
inline bool check(int id, pair<int, int> E) {
  if (edge[id].first == E.first && edge[id].second == E.second) return true;
  if (edge[id].first == E.second && edge[id].second == E.first) return true;
  return false;
}
inline void tarjan(int cur, int father) {
  dfn[cur] = low[cur] = ++Index;
  int id, first, u;
  for (register int i = 0; i < int(v[cur].size()); i++) {
    register int second =
        (edge[v[cur][i]].first == cur ? edge[v[cur][i]].second
                                      : edge[v[cur][i]].first);
    if (!dfn[second]) {
      s.push(v[cur][i]);
      tarjan(second, cur);
      low[cur] = min(low[cur], low[second]);
      if (low[second] >= dfn[cur]) {
        if (check(s.top(), make_pair(cur, second))) {
          vv[cur].push_back(make_pair(second, 1));
          vv[second].push_back(make_pair(cur, 1));
          s.pop();
          continue;
        }
        ++ind;
        val[ind] = 1;
        cir.clear();
        do {
          id = s.top();
          s.pop();
          first = edge[id].first;
          u = edge[id].second;
          cir.push_back(first);
          cir.push_back(u);
        } while (!check(id, make_pair(cur, second)));
        sort(cir.begin(), cir.end());
        cir.resize(unique(cir.begin(), cir.end()) - cir.begin());
        for (register int j = 0; j < int(cir.size()); j++)
          vv[ind].push_back(make_pair(cir[j], 0)),
              vv[cir[j]].push_back(make_pair(ind, 0));
      }
    } else if (second != father && dfn[second] < dfn[cur]) {
      s.push(v[cur][i]);
      low[cur] = min(low[cur], dfn[second]);
    }
  }
}
int sum[MAXN + 48], anc[MAXN + 48][21], depth[MAXN + 48];
inline void dfs(int cur, int father) {
  for (register int i = 0; i < int(vv[cur].size()); i++) {
    register int second = vv[cur][i].first;
    if (second != father) {
      sum[second] = sum[cur] + vv[cur][i].second + val[second];
      depth[second] = depth[cur] + 1;
      anc[second][0] = cur;
      for (register int j = 1; j <= 20; j++)
        anc[second][j] = anc[anc[second][j - 1]][j - 1];
      dfs(second, cur);
    }
  }
}
inline int get_lca(int u, int v) {
  if (depth[u] < depth[v]) swap(u, v);
  for (register int i = 20; i >= 0; i--)
    if (depth[anc[u][i]] >= depth[v]) u = anc[u][i];
  if (u == v) return u;
  for (register int i = 20; i >= 0; i--)
    if (anc[u][i] != anc[v][i]) u = anc[u][i], v = anc[v][i];
  return anc[u][0];
}
int main() {
  io.Get(n);
  io.Get(m);
  io.Get(q);
  int first, second;
  for (register int i = 1; i <= m; i++) {
    edge[i].input();
    v[edge[i].first].push_back(i);
    v[edge[i].second].push_back(i);
  }
  ind = n;
  tarjan(1, -1);
  sum[1] = val[1];
  depth[1] = 1;
  dfs(1, -1);
  while (q--) {
    io.Get(first);
    io.Get(second);
    register int LCA = get_lca(first, second);
    io.Print(sum[first] + sum[second] - 2 * sum[LCA] + val[LCA], '\n');
  }
  io.flush();
  return 0;
}
