#include <bits/stdc++.h>

 using namespace std;

 #define REP(i,n)        for(int i(0); i <  (n); ++i)

 #define rep(i,a,b)        for(int i(a); i <= (b); ++i)

 #define dec(i,a,b)        for(int i(a); i >= (b); --i)

 #define for_edge(i,x)        for(int i = H[x]; i; i = X[i])

 const int N    =            +    ;

 const int A    =            +    ;

 int father[N], List[N], deep[N], E[N], X[N], H[N], V[N];

 int f[N][A], g[N][A];

 bool v[N];

 int n, m, q, x, y, z;

 int et;

 inline void Eddedge(int a, int b, int c){

     E[++et] = b, X[et] = H[a], H[a] = et, V[et] = c;

     E[++et] = a, X[et] = H[b], H[b] = et, V[et] = c;

 }

 int getfather(int x){ return father[x] ? father[x]  = getfather(father[x]) : x; } 

 int Calc(int a, int b){

     int ret = ;

     if (deep[a] < deep[b]) swap(a, b);

     for (int i = , delta = deep[a] - deep[b]; delta; delta >>= , ++i)

         if (delta & ) ret += g[a][i], a = f[a][i];

     if (a == b) return ret;

     dec(i, , ) if (f[a][i] != f[b][i]){

         ret += g[a][i];

         ret += g[b][i];

         a = f[a][i];

         b = f[b][i];

     }

     ret += g[a][];

     ret += g[b][];

     return ret;

 }

 int main(){

     while (~scanf("%d%d%d", &n, &m, &q)){

         et = ;

         memset(father, , sizeof father);

         memset(H, , sizeof H);

         rep(i, , m){

             scanf("%d%d%d", &x, &y, &z);Eddedge(x, y, z);

             int fa = getfather(x), fb = getfather(y);

             father[fa] = fb;

         }

         int l = , r = , now = ;

         memset(List, , sizeof List);

         memset(deep, , sizeof deep);

         memset(v, false , sizeof v);

         memset(f, , sizeof f);

         memset(g, , sizeof g);

         rep(p, , n) if (!v[p]){

             for (l = , r = , v[p] = true, List[] = p; l <= r; ++l){

                 now = List[l];

                 for_edge(i, now) if (!v[E[i]]){

                     v[E[i]] = true;

                     f[E[i]][] = now;

                     g[E[i]][] = V[i];

                     deep[E[i]] = deep[now] + ;

                     for (int j = ; f[E[i]][j]; ++j)

                         f[E[i]][j + ] = f[f[E[i]][j]][j],

                             g[E[i]][j + ] = g[E[i]][j] + g[f[E[i]][j]][j];

                     List[++r] = E[i];

                 }

             }

         }

         while (q--){

             scanf("%d%d", &x, &y);

             int fa = getfather(x), fb = getfather(y);

             if (fa != fb) puts("Not connected"); else printf("%d\n", Calc(x, y));

         }

     }

     return ;

 }