#include <bits/stdc++.h>
using namespace std;
const long long N = 200005;
const long long inf = 2000000000000000005;
struct EDGE {
  long long x, y;
  long long val;
} G[N];
struct Edge {
  long long vet, nxt;
  long long val;
  long long id;
} e[N << 1];
struct Data {
  long long id;
  long long val;
  inline bool operator<(const Data &rhs) const { return val > rhs.val; }
};
struct Node {
  long long l, r;
  long long Min, lazy;
} tree[N << 2];
long long n, m, q, edge = 0, cnt = 0, head[N];
long long link[N], L[N], R[N], newid[N];
bool vis[N], p_inpath[N], e_inpath[N];
long long dis[2][N];
priority_queue<Data> Q;
inline long long read() {
  long long x = 0, f = 1;
  char ch = getchar();
  while (!isdigit(ch)) {
    if (ch == '-') f = -1;
    ch = getchar();
  }
  while (isdigit(ch)) {
    x = x * 10 + ch - '0';
    ch = getchar();
  }
  return x * f;
}
inline void addedge(long long x, long long y, long long z, long long id) {
  e[++edge].vet = y;
  e[edge].val = z, e[edge].id = id;
  e[edge].nxt = head[x];
  head[x] = edge;
}
inline void dijkstra(long long St, long long *Dis, long long flag) {
  while (!Q.empty()) Q.pop();
  for (long long i = 1; i <= n; ++i) Dis[i] = inf;
  memset(vis, 0, sizeof(vis));
  Dis[St] = 0;
  Q.push((Data){St, 0});
  while (!Q.empty()) {
    Data Top = Q.top();
    Q.pop();
    long long x = Top.id;
    if (vis[x]) continue;
    vis[x] = 1;
    for (long long i = head[x]; i; i = e[i].nxt) {
      long long v = e[i].vet;
      if (Dis[x] + e[i].val < Dis[v]) {
        link[v] = e[i].id;
        Dis[v] = Dis[x] + e[i].val;
        if ((flag == 1) && (!p_inpath[v])) L[v] = L[x];
        if ((flag == 2) && (!p_inpath[v])) R[v] = R[x];
        Q.push((Data){v, Dis[v]});
      }
    }
  }
}
inline void Getpath() {
  long long now = 1;
  p_inpath[1] = true;
  L[1] = R[1] = 0;
  while (now != n) {
    long long i = link[now];
    e_inpath[i] = true;
    newid[i] = ++cnt;
    now = now ^ G[i].x ^ G[i].y;
    p_inpath[now] = true;
    L[now] = R[now] = cnt;
  }
}
inline void pushup(long long id) {
  tree[id].Min = ((tree[(id << 1)].Min) < (tree[(id << 1 | 1)].Min)
                      ? (tree[(id << 1)].Min)
                      : (tree[(id << 1 | 1)].Min));
}
inline void pushdown(long long id) {
  if (tree[id].lazy != inf) {
    long long val = tree[id].lazy;
    tree[(id << 1)].lazy =
        ((tree[(id << 1)].lazy) < (val) ? (tree[(id << 1)].lazy) : (val));
    tree[(id << 1 | 1)].lazy =
        ((tree[(id << 1 | 1)].lazy) < (val) ? (tree[(id << 1 | 1)].lazy)
                                            : (val));
    tree[(id << 1)].Min =
        ((tree[(id << 1)].Min) < (val) ? (tree[(id << 1)].Min) : (val));
    tree[(id << 1 | 1)].Min =
        ((tree[(id << 1 | 1)].Min) < (val) ? (tree[(id << 1 | 1)].Min) : (val));
    tree[id].lazy = inf;
  }
}
inline void build(long long id, long long l, long long r) {
  tree[id].l = l, tree[id].r = r;
  tree[id].lazy = inf;
  if (l == r) {
    tree[id].Min = inf;
    return;
  }
  long long mid = (l + r) >> 1;
  build((id << 1), l, mid);
  build((id << 1 | 1), mid + 1, r);
  pushup(id);
}
inline void change(long long id, long long l, long long r, long long val) {
  if (l > r) return;
  if (tree[id].l >= l && tree[id].r <= r) {
    tree[id].lazy = ((tree[id].lazy) < (val) ? (tree[id].lazy) : (val));
    tree[id].Min = ((tree[id].Min) < (val) ? (tree[id].Min) : (val));
    return;
  }
  pushdown(id);
  long long mid = (tree[id].l + tree[id].r) >> 1;
  if (r <= mid)
    change((id << 1), l, r, val);
  else if (l > mid)
    change((id << 1 | 1), l, r, val);
  else
    change((id << 1), l, mid, val), change((id << 1 | 1), mid + 1, r, val);
  pushup(id);
}
inline long long query(long long id, long long x) {
  if (tree[id].l == tree[id].r) return tree[id].Min;
  pushdown(id);
  long long mid = (tree[id].l + tree[id].r) >> 1;
  if (x <= mid)
    return query((id << 1), x);
  else
    return query((id << 1 | 1), x);
  pushup(id);
}
signed main() {
  n = read(), m = read(), q = read();
  for (long long i = 1; i <= m; ++i) {
    long long x = read(), y = read(), z = read();
    G[i].x = x, G[i].y = y, G[i].val = z;
    addedge(x, y, z, i);
    addedge(y, x, z, i);
  }
  dijkstra(n, dis[1], 0);
  Getpath();
  dijkstra(1, dis[0], 1);
  dijkstra(n, dis[1], 2);
  build(1, 1, cnt);
  for (long long i = 1; i <= m; ++i)
    if (!e_inpath[i]) {
      long long x = G[i].x, y = G[i].y, val = G[i].val;
      change(1, L[x] + 1, R[y], dis[0][x] + dis[1][y] + val);
      change(1, L[y] + 1, R[x], dis[1][x] + dis[0][y] + val);
    }
  while (q--) {
    long long i = read(), val = read();
    long long x = G[i].x, y = G[i].y;
    if ((!e_inpath[i]) && (val >= G[i].val))
      printf("%lld\n", dis[0][n]);
    else if ((!e_inpath[i]) && (val < G[i].val)) {
      long long len1 = dis[0][n];
      long long len2 = dis[0][x] + dis[1][y] + val;
      long long len3 = dis[0][y] + dis[1][x] + val;
      printf("%lld\n", ((len1) < (((len2) < (len3) ? (len2) : (len3)))
                            ? (len1)
                            : (((len2) < (len3) ? (len2) : (len3)))));
    } else if ((e_inpath[i]) && (val < G[i].val))
      printf("%lld\n", dis[0][n] - G[i].val + val);
    else {
      long long len1 = dis[0][n] - G[i].val + val;
      long long len2 = query(1, newid[i]);
      printf("%lld\n", ((len1) < (len2) ? (len1) : (len2)));
    }
  }
  return 0;
}
