#include <bits/stdc++.h>
using namespace std;
const int c=3e5+5;
const int ce=1e6+6;

int n,m,q,tt,K;
vector<int> adj[c];
bool volt[ce], vis[c];
int vag[c], t[c], l[c], cnt[c], dep[c];
int mp[c];
vector<vector<int>> comp;
vector<pair<int,int>> s;
vector<int> tree[c];

void dfs(int v, int p){
    t[v]=l[v]=++tt;
    int vag1=0;
    for(int x:adj[v]){
        if(x==p) continue;
        if(!t[x]){
            vag1++;
            s.push_back(make_pair(v,x));
            dfs(x,v);
            l[v]=min(l[v],l[x]);
            if(l[x]>=t[v] && p){
                if(!vag[v]) vag[v]=++K;
                comp.push_back(vector<int>());
                while(!s.empty()){
                    int a=s.back().first,b=s.back().second;
                    comp.back().push_back(a);
                    comp.back().push_back(b);
                    s.pop_back();
                    if(a==v) break;
                }
            }

            if(!p){
                comp.push_back(vector<int>());
                while(!s.empty()){
                    comp.back().push_back(s.back().first);
                    comp.back().push_back(s.back().second);
                    s.pop_back();
                }
            }
        }
        else l[v]=min(l[v],t[x]);
    }

    if(vag1>1 && !p) vag[1]=++K;
}

void build(){
    for(int i=1;i<=n;i++){
        if(vag[i]) {mp[i]=vag[i]+comp.size(); cnt[mp[i]]=-1;}
    }

    for(int i=0;i<comp.size();i++){
        vector<int> cut;
        sort(comp[i].begin(),comp[i].end());
        comp[i].resize(unique(comp[i].begin(),comp[i].end())-comp[i].begin());
        cnt[i+1]=comp[i].size();

        for(int x:comp[i])
        {
            if(!vag[x]) mp[x]=i+1;
            else {
                cut.push_back(x);
                tree[i+1].push_back(mp[x]);
                tree[mp[x]].push_back(i+1);
            }
        }
    }
}

int up[c][19];
int sum[c][19];

void dfs2(int v, int p){
    up[v][0]=p;
    sum[v][0]=cnt[v];
    for(int i=1;i<19;i++){
        int x = up[v][i-1];
        up[v][i]=up[x][i-1];
        sum[v][i]=sum[v][i-1]+sum[x][i-1];
    }

    for(int x:tree[v]){
        if(x != p){
            dep[x]=dep[v]+1;
            dfs2(x,v);
        }
    }
}

int query(int a, int b){
    int res=(vag[a]>0) + (vag[b]>0);
    a=mp[a], b=mp[b];

    if(dep[a]>dep[b]) swap(a,b);
    int k=dep[b]-dep[a];
    for(int i=18;i>=0;i--){
        if((k>>i)&1){
            res+=sum[b][i];
            b=up[b][i];
        }
    }

    if(a==b){
        res+=sum[a][0];
        return res;
    }

    for(int i=18;i>=0;i--){
        if(up[a][i] != up[b][i]){
            res+=sum[a][i]+sum[b][i];
            a=up[a][i], b=up[b][i];
        }
    }
    res+=sum[up[a][0]][0];
    return res;
}

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

    cin>>n>>m>>q;

    for(int i=1;i<=m;i++){
        int a,b; cin>>a>>b;
        adj[a].push_back(b);
        adj[b].push_back(a);
    }

    dfs(1,0);
    build();
    dfs2(1,0);
    while(q--){
        int a,b; cin>>a>>b;
        cout << query(a,b)-2 << '\n';
    }
}