func_code_string: #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(); }   