#include <bits/stdc++.h>
using namespace std;
using ll=long long;


void solve();

int main(){
    ios_base::sync_with_stdio(0); cin.tie(0);

    int t=1;
    //cin>>t;
    while (t--) solve();
}

const int maxn=4e5+1;

int n,m,k;
vector<vector<int>> g(maxn);
vector<int> t(maxn, -1),l(maxn, -1);
vector<bool> vis(maxn,false);
int timer=0;
stack<int> st;
vector<vector<int>> comps;
vector<int> art(maxn);
vector<int> comp(maxn,-1);
void dfs(int v, int p=-1){
    t[v]=l[v]=++timer;
    vis[v]=true;
    st.push(v);
    for (int to : g[v]){
        if (p==to) continue;
        if (vis[to]){
            l[v]=min(l[v], t[to]);
        }
        else {
            dfs(to, v);
            l[v]=min(l[v], l[to]);

            if (l[to]>=t[v]){
                art[v]= (t[v]>1 || t[to]>2);
                comps.push_back({v});
                comp[v]=comps.size()-1;
                while (comps.back().back()!=to){
                    comps.back().push_back(st.top());
                    comp[st.top()]=comps.size()-1;
                    st.pop();
                }
            }
        }
    }
}


vector<bool> bctvis(maxn,false);
vector<vector<int>> bctg(maxn);

void bct(int v){
    bctvis[v]=true;
    if (comps[v].size()==1){
        for (int to : g[comps[v][0]]){
            if (!bctvis[comp[to]]) bct(comp[to]);
        }
    }else {
        for (int node : comps[v]){
            if (art[node]){
                bctg[v].push_back(comp[node]);
                if (!bctvis[comp[node]]) bct(comp[node]);
            }
        }
    }
}

vector<int> pr(maxn,1);
vector<vector<int>> binary(maxn, vector<int> (20, 0));
vector<int> layer(maxn, -1);

void pref(int v, int p=-1){
    pr[v]=pr[max(p,0)]-1+comps[v].size();
    layer[v]=layer[max(p,0)]+1;
    if (p!=-1){
        binary[v][0]=p;
        for (int i=1;i<20;i++){
            binary[v][i]=binary[binary[v][i-1]][i-1];
        }
    }
    for (int to : bctg[v]){
        if (to==p) continue;
        pref(to,v);
    }
}

int lca(int a,int b){
    if (layer[a]<layer[b]) swap(a,b);
    if (layer[a]>layer[b]){
        for (int i=19;i>=0;i--){
            int c=binary[a][i];
            if (layer[c]<=layer[b]) continue;
            a=c;
        }
        a=binary[a][0];
    }
    if (a==b) return a;
    for (int i=19;i>=0;i--){
        int c=binary[a][i];
        int d=binary[b][i];
        if (c==d) continue;
        a=c;
        b=d;
    }
    return binary[a][0];
}

void solve(){
    cin>>n>>m>>k;
    for (int i = 0; i < m; i++)
    {
        int a,b;
        cin>>a>>b;
        g[a].push_back(b);
        g[b].push_back(a);
    }

    dfs(1);
    for (int i=1;i<=n;i++){
        if (art[i]){
            comps.push_back({i});
            comp[i]=comps.size()-1;
        }
    }
    for (int i=0;i<comps.size();i++){
        if (comps[i].size()==1) continue;
        for (int j : comps[i]){
            if (art[j]) bctg[comp[j]].push_back(i);
        }
    }
    bct(0);
    pref(0);

    for (int i = 0; i < k; i++)
    {
        int a,b;
        cin>>a>>b;

        a=comp[a];
        b=comp[b];

        int c = lca(a,b);

        cout<<pr[a]+pr[b]-2*pr[c]+comps[c].size()-2<<"\n";
    }
    

}