#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int head[200005], cnt;
int from[200005], to[200005];
long long pre[200005], suf[200005];
int last[200005];
bool visit[200005], token[200005];
int sign[200005], total;
struct node {
  int u;
  long long d;
  node(int u = 0, long long d = 0) : u(u), d(d) {}
  bool operator<(const node b) const { return d > b.d; }
};
struct data {
  int next, to, cost, id;
  data(int next = 0, int to = 0, int cost = 0, int id = 0)
      : next(next), to(to), cost(cost), id(id) {}
} edge[200005 << 1];
struct segment {
  int l, r;
  long long v;
} t[200005 << 2];
struct section {
  int u, v, w;
  section(int u = 0, int v = 0, int w = 0) : u(u), v(v), w(w) {}
} a[200005];
int read() {
  char c = getchar();
  int x = 0;
  while (!isdigit(c)) c = getchar();
  while (isdigit(c)) {
    x = (x << 3) + (x << 1) + c - '0';
    c = getchar();
  }
  return x;
}
void build(int l, int r, int x = 1) {
  t[x].v = 0x3f3f3f3f3f3f3f3f;
  t[x].l = l;
  t[x].r = r;
  if (l == r) return;
  int mid = (l + r) >> 1;
  build(l, mid, x << 1);
  build(mid + 1, r, x << 1 | 1);
}
void modify(int l, int r, long long v, int x = 1) {
  if (l > r) return;
  if (l <= t[x].l && t[x].r <= r) {
    t[x].v = min(t[x].v, v);
    return;
  }
  int mid = (t[x].l + t[x].r) >> 1;
  if (l <= mid) modify(l, r, v, x << 1);
  if (r > mid) modify(l, r, v, x << 1 | 1);
}
long long query(int p, int x = 1) {
  if (t[x].l == t[x].r) return t[x].v;
  int mid = (t[x].l + t[x].r) >> 1;
  if (p <= mid)
    return min(t[x].v, query(p, x << 1));
  else
    return min(t[x].v, query(p, x << 1 | 1));
}
void connect(int u, int v, int w, int id) {
  edge[++cnt] = data(head[u], v, w, id);
  head[u] = cnt;
}
void Dijkstra(int S, long long* d, int type) {
  memset(visit, 0, sizeof(visit));
  priority_queue<node> q;
  for (int i = 1; i <= n; ++i) d[i] = 0x3f3f3f3f3f3f3f3f;
  d[S] = 0;
  q.push(node(S, d[S]));
  while (!q.empty()) {
    int u = q.top().u;
    q.pop();
    if (visit[u]) continue;
    visit[u] = true;
    for (int i = head[u]; i; i = edge[i].next) {
      int v = edge[i].to, w = edge[i].cost;
      if (d[u] + w < d[v]) {
        if (type == 1) last[v] = edge[i].id;
        if (type == 2 && !token[v]) from[v] = from[u];
        if (type == 3 && !token[v]) to[v] = to[u];
        d[v] = d[u] + w;
        q.push(node(v, d[v]));
      }
    }
  }
}
void find() {
  int cur = 1;
  while (cur != n) {
    sign[last[cur]] = ++total;
    token[cur] = true;
    from[cur] = to[cur] = total;
    cur = a[last[cur]].u ^ a[last[cur]].v ^ cur;
  }
  token[n] = true;
  from[n] = to[n] = total + 1;
}
int main() {
  n = read();
  m = read();
  q = read();
  for (int i = 1; i <= m; ++i) {
    int u = read(), v = read(), w = read();
    connect(u, v, w, i);
    connect(v, u, w, i);
    a[i] = section(u, v, w);
  }
  Dijkstra(n, suf, 1);
  find();
  Dijkstra(1, pre, 2);
  Dijkstra(n, suf, 3);
  build(1, total);
  for (int i = 1; i <= m; ++i) {
    int u = a[i].u, v = a[i].v, w = a[i].w;
    if (sign[i]) continue;
    modify(from[u], to[v] - 1, pre[u] + suf[v] + w);
    modify(from[v], to[u] - 1, pre[v] + suf[u] + w);
  }
  while (q--) {
    int t = read(), w = read(), u = a[t].u, v = a[t].v;
    if (sign[t])
      printf("%I64d\n", min(pre[n] + w - a[t].w, query(sign[t])));
    else
      printf("%I64d\n",
             min(pre[n], min(pre[u] + suf[v] + w, pre[v] + suf[u] + w)));
  }
}
