#include <bits/stdc++.h>
struct Data {
  int x, y, z;
  Data() {}
  Data(int x, int y, int z) : x(x), y(y), z(z) {}
} a[200010];
struct Graph {
  int to[200010 << 1], ne[200010 << 1], w[200010 << 1], head[200010], cnt;
  Graph() : cnt(1) {}
  void add_edge(int x, int y, int z) {
    to[++cnt] = y, ne[cnt] = head[x], w[cnt] = z, head[x] = cnt;
    to[++cnt] = x, ne[cnt] = head[y], w[cnt] = z, head[y] = cnt;
  }
  int operator[](int x) { return head[x]; }
} G;
int N, M, Q, lp[200010], rp[200010], id[200010], pre[200010];
long long dis1[200010], disn[200010], cnt1[200010], cntn[200010];
bool vis[200010], fl[200010];
std::priority_queue<std::pair<long long, int> > q;
std::unordered_map<int, std::unordered_map<int, int> > dis;
void work1(int x, int y, int idx) { pre[y] = idx; }
void work2(int x, int y, int idx) {
  if (!fl[y]) lp[y] = lp[x];
  cnt1[y] += cnt1[x];
}
void work3(int x, int y, int idx) {
  if (!fl[y]) rp[y] = rp[x];
  cntn[y] += cntn[x];
}
template <void (*func)(int, int, int)>
void dij(int S, long long *dis) {
  memset(dis, 0x3f, sizeof(dis1));
  memset(vis, 0, sizeof(vis));
  dis[S] = 0;
  q.push(std::make_pair(0, S));
  while (!q.empty()) {
    int x = q.top().second;
    q.pop();
    if (vis[x]) continue;
    vis[x] = true;
    for (int i = G[x]; i; i = G.ne[i])
      if (dis[G.to[i]] > dis[x] + G.w[i]) {
        func(x, G.to[i], i);
        dis[G.to[i]] = dis[x] + G.w[i];
        q.push(std::make_pair(-dis[G.to[i]], G.to[i]));
      }
  }
}
namespace Seg {
long long mn[200010 << 2], tag[200010 << 2];
void push_down(int v) {
  mn[(v << 1)] = std::min(mn[(v << 1)], tag[v]);
  tag[(v << 1)] = std::min(tag[(v << 1)], tag[v]);
  mn[(v << 1 | 1)] = std::min(mn[(v << 1 | 1)], tag[v]);
  tag[(v << 1 | 1)] = std::min(tag[(v << 1 | 1)], tag[v]);
  tag[v] = 0x3f3f3f3f3f3f3f3f;
}
void push_up(int v) { mn[v] = std::min(mn[(v << 1)], mn[(v << 1 | 1)]); }
void modify(int v, int l, int r, int ql, int qr, long long val) {
  if (ql > qr) return;
  if (ql <= l && r <= qr) {
    tag[v] = std::min(tag[v], val);
    mn[v] = std::min(mn[v], val);
    return;
  }
  push_down(v);
  if (ql <= ((l + r) >> 1)) modify((v << 1), l, ((l + r) >> 1), ql, qr, val);
  if (qr > ((l + r) >> 1))
    modify((v << 1 | 1), ((l + r) >> 1) + 1, r, ql, qr, val);
  push_up(v);
}
long long query(int l, int r, int p) {
  int v = 1;
  while (l < r) {
    push_down(v);
    if (p <= ((l + r) >> 1))
      v = (v << 1), r = ((l + r) >> 1);
    else
      l = ((l + r) >> 1) + 1, v = (v << 1 | 1);
  }
  return mn[v];
}
}  // namespace Seg
int main() {
  memset(lp, -1, sizeof(lp));
  memset(rp, -1, sizeof(rp));
  memset(Seg::mn, 0x3f, sizeof(Seg::mn));
  memset(Seg::tag, 0x3f, sizeof(Seg::tag));
  int x, y, z;
  scanf("%d%d%d", &N, &M, &Q);
  for (int i = 1; i <= M; i++) {
    scanf("%d%d%d", &x, &y, &z);
    G.add_edge(x, y, z);
    a[i] = Data(x, y, z);
    dis[x][y] = dis[y][x] = z;
  }
  dij<work1>(1, dis1);
  int tot = 0;
  for (int i = pre[N], p = N; pre[p]; i = pre[p]) {
    id[i >> 1] = ++tot;
    lp[p] = tot;
    fl[p] = true;
    p ^= a[i >> 1].x ^ a[i >> 1].y;
    rp[p] = tot;
    fl[p] = true;
  }
  lp[1] = tot + 1, rp[N] = 0;
  dij<work2>(1, dis1);
  dij<work3>(N, disn);
  for (int i = 1; i <= M; i++)
    if (!id[i]) {
      Seg::modify(1, 1, tot, rp[a[i].y] + 1, lp[a[i].x] - 1,
                  dis1[a[i].x] + disn[a[i].y] + a[i].z);
      Seg::modify(1, 1, tot, rp[a[i].x] + 1, lp[a[i].y] - 1,
                  dis1[a[i].y] + disn[a[i].x] + a[i].z);
    }
  while (Q--) {
    scanf("%d%d", &x, &y);
    long long ans = dis1[a[x].x] + disn[a[x].y] + y;
    ans = std::min(ans, dis1[a[x].y] + disn[a[x].x] + y);
    if (a[x].z >= y) {
      if (!id[x]) ans = std::min(ans, dis1[N]);
      printf("%I64d\n", ans);
    } else {
      if (!id[x])
        printf("%I64d\n", dis1[N]);
      else {
        ans = std::min(ans, Seg::query(1, tot, id[x]));
        printf("%I64d\n", ans);
      }
    }
  }
  return 0;
}
