#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rd(T &x) {
  char ch;
  x = 0;
  bool fl = false;
  while (!isdigit(ch = getchar())) (ch == '-') && (fl = true);
  for (x = (ch ^ '0'); isdigit(ch = getchar()); x = x * 10 + (ch ^ '0'))
    ;
  (fl == true) && (x = -x);
}
template <class T>
inline void output(T x) {
  if (x / 10) output(x / 10);
  putchar(x % 10 + '0');
}
template <class T>
inline void ot(T x) {
  if (x < 0) putchar('-'), x = -x;
  output(x);
  putchar(' ');
}
template <class T>
inline void prt(T a[], int st, int nd) {
  for (register int i = st; i <= nd; ++i) ot(a[i]);
  putchar('\n');
}
namespace Miracle {
const int N = 2e5 + 5;
const int M = 2e5 + 5;
const long long inf = 0x3f3f3f3f3f3f3f3f;
int n, m, Q;
struct edge {
  int x, y, z;
} b[M];
int vis[N];
int pre[N];
int on[N], is[M];
int up, id[N], bi[M];
struct node {
  int nxt, to, val;
} e[2 * M];
int hd[N], cnt = 1;
void add(int x, int y, int z) {
  e[++cnt].nxt = hd[x];
  e[cnt].to = y;
  e[cnt].val = z;
  hd[x] = cnt;
}
struct po {
  int id;
  long long val;
  po() {}
  po(int dd, long long vv) {
    id = dd;
    val = vv;
  }
  bool friend operator<(po a, po b) { return a.val > b.val; }
};
priority_queue<po> q;
long long dis[2][N];
void init() {
  memset(dis[1], 0x3f, sizeof dis[1]);
  dis[1][n] = 0;
  q.push(po(n, 0));
  while (!q.empty()) {
    po now = q.top();
    q.pop();
    if (vis[now.id]) continue;
    int x = now.id;
    vis[x] = 1;
    for (register int i = hd[x]; i; i = e[i].nxt) {
      int y = e[i].to;
      if (dis[1][y] > dis[1][x] + e[i].val) {
        dis[1][y] = dis[1][x] + e[i].val;
        pre[y] = i;
        q.push(po(y, dis[1][y]));
      }
    }
  }
}
int lim[N][2];
void dij(int typ) {
  memset(dis[typ], 0x3f, sizeof dis[typ]);
  memset(vis, 0, sizeof vis);
  while (!q.empty()) q.pop();
  if (typ)
    q.push(po(n, 0)), dis[1][n] = 0;
  else
    q.push(po(1, 0)), dis[0][1] = 0;
  while (!q.empty()) {
    po now = q.top();
    q.pop();
    if (vis[now.id]) continue;
    int x = now.id;
    vis[x] = 1;
    for (register int i = hd[x]; i; i = e[i].nxt) {
      int y = e[i].to;
      if (dis[typ][y] > dis[typ][x] + e[i].val) {
        dis[typ][y] = dis[typ][x] + e[i].val;
        if (on[x]) {
          lim[y][typ] = id[x];
        } else {
          lim[y][typ] = lim[x][typ];
        }
        q.push(po(y, dis[typ][y]));
      }
    }
  }
}
struct tr {
  long long mi;
  tr() { mi = inf; }
} t[4 * N];
void chan(int x, int l, int r, int L, int R, long long c) {
  if (L < 1 || R > up) return;
  if (L <= l && r <= R) {
    t[x].mi = min(t[x].mi, c);
    return;
  }
  if (L <= ((l + r) >> 1)) chan(x << 1, l, ((l + r) >> 1), L, R, c);
  if (((l + r) >> 1) < R) chan(x << 1 | 1, ((l + r) >> 1) + 1, r, L, R, c);
}
void query(int x, int l, int r, int p, long long &ans) {
  if (l == r) {
    ans = min(ans, t[x].mi);
    return;
  }
  ans = min(ans, t[x].mi);
  if (p <= ((l + r) >> 1))
    query(x << 1, l, ((l + r) >> 1), p, ans);
  else
    query(x << 1 | 1, ((l + r) >> 1) + 1, r, p, ans);
}
int main() {
  rd(n);
  rd(m);
  rd(Q);
  int x, y, z;
  for (register int i = 1; i <= m; ++i) {
    rd(x);
    rd(y);
    rd(z);
    add(x, y, z);
    add(y, x, z);
    b[i].x = x;
    b[i].y = y;
    b[i].z = z;
  }
  init();
  x = 1;
  while (x) {
    on[x] = 1;
    is[pre[x] / 2] = 1;
    ++up;
    id[x] = up;
    bi[pre[x] / 2] = up;
    x = e[pre[x] ^ 1].to;
  }
  dij(0);
  dij(1);
  for (register int i = 1; i <= n; ++i) {
    if (on[i]) {
      lim[i][0] = lim[i][1] = id[i];
    }
  }
  lim[1][0] = 1;
  lim[n][1] = up;
  for (register int i = 1; i <= m; ++i) {
    int x = b[i].x, y = b[i].y;
    if (!is[i]) {
      long long len = dis[0][x] + dis[1][y] + b[i].z;
      if (lim[x][0] <= lim[y][1] - 1)
        chan(1, 1, up, lim[x][0], lim[y][1] - 1, len);
      len = dis[1][x] + dis[0][y] + b[i].z;
      if (lim[y][0] <= lim[x][1] - 1)
        chan(1, 1, up, lim[y][0], lim[x][1] - 1, len);
    }
  }
  while (Q--) {
    rd(x);
    rd(z);
    long long ans = inf;
    if (is[x]) {
      if (z <= b[x].z) {
        ans = dis[0][n] - (b[x].z - z);
      } else {
        query(1, 1, up, bi[x], ans);
        ans = min(ans, min(dis[0][b[x].x] + dis[1][b[x].y] + z,
                           dis[1][b[x].x] + dis[0][b[x].y] + z));
      }
    } else {
      ans = min(dis[0][n], min(dis[0][b[x].x] + dis[1][b[x].y] + z,
                               dis[1][b[x].x] + dis[0][b[x].y] + z));
    }
    printf("%lld\n", ans);
  }
  return 0;
}
}  // namespace Miracle
signed main() {
  Miracle::main();
  return 0;
}
