#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18 + 10;
struct Edge {
  int nr, u, v, d;
};
struct Vert {
  int nr;
  long long d;
  int p;
};
struct Tree {
  int base = 1;
  vector<long long> tab;
  void init(int n) {
    while (base < n + 2) base *= 2;
    tab.assign(2 * base, inf);
  }
  void insert(int a, int b, long long val) {
    if (a >= b) return;
    a += base;
    b += base;
    while (a / 2 != b / 2) {
      if (a % 2 == 0) tab[a + 1] = min(tab[a + 1], val);
      if (b % 2 == 1) tab[b - 1] = min(tab[b - 1], val);
      a /= 2;
      b /= 2;
    }
  }
  long long query(int a) {
    a += base;
    long long res = inf;
    while (a >= 1) {
      res = min(res, tab[a]);
      a /= 2;
    }
    return res;
  }
};
int n, m, q, k = 0;
vector<Edge> E[300000], edges;
int pathEdgeNr[300000];
vector<int> L, R;
vector<long long> dist1, distN;
Tree tree;
template <typename Func>
void dijkstra(int start, vector<long long>& dist, vector<int>& V, int v,
              Func compare) {
  dist.assign(n + 1, inf);
  V.assign(n + 1, v);
  priority_queue<Vert, vector<Vert>, decltype(compare)> Q(compare);
  Q.push({start, 0, v});
  while (!Q.empty()) {
    Vert vert = Q.top();
    Q.pop();
    if (dist[vert.nr] != inf) continue;
    dist[vert.nr] = vert.d;
    V[vert.nr] = vert.p;
    for (Edge edge : E[vert.nr]) {
      int p = vert.p;
      if (pathEdgeNr[edge.nr] != 0) {
        p = pathEdgeNr[edge.nr];
      }
      Q.push({edge.v, vert.d + edge.d, p});
    }
  }
}
void findPath() {
  int a = 1;
  while (a != n) {
    for (Edge edge : E[a]) {
      if (dist1[edge.u] + edge.d + distN[edge.v] == dist1[n]) {
        pathEdgeNr[edge.nr] = ++k;
        a = edge.v;
        break;
      }
    }
  }
}
void solve() {
  cin >> n >> m >> q;
  edges.push_back({0, 0, 0, 0});
  for (int i = 1; i <= m; i++) {
    int a, b, c;
    cin >> a >> b >> c;
    edges.push_back({i, a, b, c});
    E[a].push_back({i, a, b, c});
    E[b].push_back({i, b, a, c});
  }
  dijkstra(1, dist1, L, 0, [](const Vert& vert1, const Vert& vert2) {
    return vert1.d > vert2.d;
  });
  dijkstra(n, distN, R, 0, [](const Vert& vert1, const Vert& vert2) {
    return vert1.d > vert2.d;
  });
  findPath();
  dijkstra(1, dist1, L, 0, [](const Vert& vert1, const Vert& vert2) {
    return pair<long long, int>(vert1.d, vert1.p) >
           pair<long long, int>(vert2.d, vert2.p);
  });
  dijkstra(n, distN, R, k + 1, [](const Vert& vert1, const Vert& vert2) {
    return pair<long long, int>(vert1.d, -vert1.p) >
           pair<long long, int>(vert2.d, -vert2.p);
  });
  tree.init(k + 10);
  for (Edge edge : edges) {
    if (!pathEdgeNr[edge.nr]) {
      tree.insert(L[edge.u], R[edge.v], dist1[edge.u] + edge.d + distN[edge.v]);
      tree.insert(L[edge.v], R[edge.u], dist1[edge.v] + edge.d + distN[edge.u]);
    }
  }
  for (int i = 0; i < q; i++) {
    int t, x;
    long long res;
    cin >> t >> x;
    if (pathEdgeNr[t]) {
      res = min(dist1[n] + x - edges[t].d, tree.query(pathEdgeNr[t]));
    } else {
      res = min(dist1[n], dist1[edges[t].u] + x + distN[edges[t].v]);
      res = min(res, dist1[edges[t].v] + x + distN[edges[t].u]);
    }
    cout << res << "\n";
  }
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout << fixed << setprecision(10);
  solve();
}
