#include <bits/stdc++.h>
using namespace std;
struct Segtree {
  long long val[200005 << 2], cnt[200005 << 2];
  inline void build(int l, int r, int k) {
    val[k] = cnt[k] = 1e18;
    if (l == r) return;
    int mid = l + r >> 1;
    build(l, mid, k << 1);
    build(mid + 1, r, k << 1 | 1);
  }
  inline void pushdown(int k) {
    if (cnt[k] < 1e18) {
      val[k << 1] = min(val[k << 1], cnt[k]);
      cnt[k << 1] = min(cnt[k << 1], cnt[k]);
      val[k << 1 | 1] = min(val[k << 1 | 1], cnt[k]);
      cnt[k << 1 | 1] = min(cnt[k << 1 | 1], cnt[k]);
      cnt[k] = 1e18;
    }
  }
  inline void chkmin(int l, int r, int k, int L, int R, long long w) {
    if (L <= l && r <= R) {
      val[k] = min(val[k], w);
      cnt[k] = min(cnt[k], w);
      return;
    }
    int mid = l + r >> 1;
    pushdown(k);
    if (L <= mid) chkmin(l, mid, k << 1, L, R, w);
    if (mid < R) chkmin(mid + 1, r, k << 1 | 1, L, R, w);
    val[k] = max(val[k << 1], val[k << 1 | 1]);
  }
  inline long long query(int l, int r, int k, int L, int R) {
    if (L <= l && r <= R) return val[k];
    int mid = l + r >> 1;
    pushdown(k);
    long long ans = 1e18;
    if (L <= mid) ans = min(ans, query(l, mid, k << 1, L, R));
    if (mid < R) ans = min(ans, query(mid + 1, r, k << 1 | 1, L, R));
    return ans;
  }
} sgt;
int lg2[200005];
struct Tree {
  int head[200005], to[200005], nxt[200005], cnt;
  inline void addedge(int x, int y) {
    to[++cnt] = y, nxt[cnt] = head[x], head[x] = cnt;
  }
  int fa[200005][20], dep[200005];
  inline void dfs(int x) {
    for (int k = 1; k <= lg2[dep[x] - 1]; k++)
      fa[x][k] = fa[fa[x][k - 1]][k - 1];
    for (int i = head[x]; i; i = nxt[i]) {
      int y = to[i];
      if (y != fa[x][0]) {
        fa[y][0] = x, dep[y] = dep[x] + 1;
        dfs(y);
      }
    }
  }
  inline int lca(int x, int y) {
    if (dep[x] < dep[y]) swap(x, y);
    while (dep[x] > dep[y]) x = fa[x][lg2[dep[x] - dep[y]]];
    for (int k = lg2[dep[x]]; x != y;) {
      while (k && fa[x][k] == fa[y][k]) k--;
      x = fa[x][k], y = fa[y][k];
    }
    return x;
  }
} tre1, tre2;
struct Edge {
  int u, v, w;
  bool mark;
} edge[200005];
struct Graph {
  int head[200005], to[200005 << 1], nxt[200005 << 1], len[200005 << 1], cnt;
  inline void addedge(int x, int y, int z) {
    to[++cnt] = y, nxt[cnt] = head[x], head[x] = cnt, len[cnt] = z;
    to[++cnt] = x, nxt[cnt] = head[y], head[y] = cnt, len[cnt] = z;
  }
  long long dis[200005];
  bool mark[200005];
  inline void dijkstra(int n, int s, Tree& tre) {
    priority_queue<pair<long long, int>, vector<pair<long long, int>>,
                   greater<pair<long long, int>>>
        q;
    while (!q.empty()) q.pop();
    memset(dis, 0x7f, sizeof(dis));
    dis[s] = 0;
    q.push(pair<long long, int>(0, s));
    while (!q.empty()) {
      int x = q.top().second;
      q.pop();
      if (mark[x])
        continue;
      else
        mark[x] = 1;
      for (int i = head[x]; i; i = nxt[i]) {
        int y = to[i];
        if (dis[y] > dis[x] + len[i]) {
          dis[y] = dis[x] + len[i];
          q.push(pair<long long, int>(dis[y], y));
        }
      }
    }
    for (int x = 1; x <= n; x++) {
      if (x == s) continue;
      for (int i = head[x]; i; i = nxt[i]) {
        int y = to[i];
        if (dis[x] == dis[y] + len[i]) {
          tre.addedge(y, x);
          break;
        }
      }
    }
    tre.dep[s] = 1, tre.dfs(s);
  }
} G1, G2;
int id[200005];
bool mark[200005];
int main() {
  int n, m, q;
  scanf("%d%d%d", &n, &m, &q);
  lg2[0] = -1, lg2[1] = 0;
  for (int i = 2; i <= n; i++) lg2[i] = lg2[i >> 1] + 1;
  for (int i = 1; i <= m; i++) {
    scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].w);
    G1.addedge(edge[i].u, edge[i].v, edge[i].w);
    G2.addedge(edge[i].u, edge[i].v, edge[i].w);
  }
  G1.dijkstra(n, 1, tre1);
  G2.dijkstra(n, n, tre2);
  int len = 0;
  for (int x = 1; x; x = tre2.fa[x][0]) id[x] = ++len;
  for (int i = 1; i <= m; i++) {
    int u = edge[i].u, v = edge[i].v;
    if (!id[u] || !id[v]) continue;
    if (!mark[u] && u == tre1.fa[v][0] && G1.dis[u] + edge[i].w == G1.dis[v])
      edge[i].mark = mark[u] = true;
    else if (!mark[v] && v == tre1.fa[u][0] &&
             G1.dis[u] == G1.dis[v] + edge[i].w)
      edge[i].mark = mark[v] = true;
  }
  sgt.build(1, len - 1, 1);
  for (int i = 1; i <= m; i++) {
    int u = edge[i].u, v = edge[i].v, w = edge[i].w;
    if (edge[i].mark || !tre1.dep[u]) continue;
    int lx = tre1.lca(u, n), rx = tre2.lca(v, 1);
    if (id[lx] < id[rx])
      sgt.chkmin(1, len - 1, 1, id[lx], id[rx] - 1, G1.dis[u] + w + G2.dis[v]);
    lx = tre1.lca(v, n), rx = tre2.lca(u, 1);
    if (id[lx] < id[rx])
      sgt.chkmin(1, len - 1, 1, id[lx], id[rx] - 1, G1.dis[v] + w + G2.dis[u]);
  }
  long long mind = G1.dis[n];
  while (q--) {
    int x, w;
    scanf("%d%d", &x, &w);
    int u = edge[x].u, v = edge[x].v;
    long long ans;
    if (!tre1.dep[u])
      ans = mind;
    else if (edge[x].w >= w)
      ans =
          min(mind, min(G1.dis[u] + w + G2.dis[v], G1.dis[v] + w + G2.dis[u]));
    else if (edge[x].mark) {
      if (id[u] > id[v]) swap(u, v);
      ans =
          min(mind - edge[x].w + w, sgt.query(1, len - 1, 1, id[u], id[v] - 1));
    } else
      ans = mind;
    printf("%I64d\n", ans);
  }
  return 0;
}
