#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
const int MAXM = 2e5 + 5;
const long long Inf = 1e18;
struct Original_Edge {
  int u, v;
  long long len;
} oe[MAXM];
struct Node {
  int pos;
  long long dis;
  inline bool operator<(const Node &x) const { return x.dis < dis; }
};
struct Edge {
  int id, to, nxt;
  long long len;
} e[MAXM << 1];
int cnt, head[MAXN];
inline void add_edge(int id, int u, int v, long long len) {
  e[++cnt].id = id;
  e[cnt].to = v;
  e[cnt].nxt = head[u];
  e[cnt].len = len;
  head[u] = cnt;
}
int n, m, q;
int ind[MAXN];
int lstvis[MAXN];
int path_cnt, l[MAXN], r[MAXN];
bool On_path[MAXN];
long long disS[MAXN], disT[MAXN];
priority_queue<Node> pq;
long long t[MAXM << 4];
inline void Dijkstra(int s, long long dis[], int f = 0) {
  for (int i = 1; i <= n; ++i) dis[i] = Inf;
  dis[s] = 0;
  pq.push((Node){s, 0});
  while (!pq.empty()) {
    Node fa = pq.top();
    pq.pop();
    int x = fa.pos;
    if (fa.dis > dis[x]) continue;
    for (int i = head[x]; i; i = e[i].nxt) {
      int y = e[i].to;
      if (dis[y] > fa.dis + e[i].len) {
        lstvis[y] = e[i].id;
        dis[y] = fa.dis + e[i].len;
        if (f == 1 && !On_path[y]) l[y] = l[x];
        if (f == 2 && !On_path[y]) r[y] = r[x];
        pq.push((Node){y, dis[y]});
      }
    }
  }
}
inline void Trace() {
  On_path[1] = true;
  l[1] = r[1] = 0;
  int cur = 1;
  for (int i = 1; cur != n; ++i) {
    int Edge_id = lstvis[cur];
    ind[Edge_id] = i;
    ++path_cnt;
    cur = oe[Edge_id].u ^ oe[Edge_id].v ^ cur;
    On_path[cur] = true;
    l[cur] = r[cur] = i;
  }
}
inline void Build(int k, int l, int r) {
  t[k] = Inf;
  if (l == r) return;
  int mid = (l + r) >> 1;
  Build(k << 1, l, mid);
  Build(k << 1 | 1, mid + 1, r);
}
inline void Update(int k, int l, int r, int x, int y, long long v) {
  if (x > y) return;
  if (x <= l && r <= y) {
    t[k] = min(t[k], v);
    return;
  }
  int mid = l + r >> 1;
  if (x <= mid) Update(k << 1, l, mid, x, y, v);
  if (y > mid) Update(k << 1 | 1, mid + 1, r, x, y, v);
}
inline long long Query(int k, int l, int r, int x) {
  if (l == r) return t[k];
  int mid = l + r >> 1;
  long long res = t[k];
  if (x <= mid)
    res = min(res, Query(k << 1, l, mid, x));
  else
    res = min(res, Query(k << 1 | 1, mid + 1, r, x));
  return res;
}
int main() {
  ios::sync_with_stdio(0);
  cin >> n >> m >> q;
  for (int i = 1; i <= m; ++i) {
    cin >> oe[i].u >> oe[i].v >> oe[i].len;
    add_edge(i, oe[i].u, oe[i].v, oe[i].len);
    add_edge(i, oe[i].v, oe[i].u, oe[i].len);
    ind[i] = -1;
  }
  Dijkstra(n, disT);
  Trace();
  Dijkstra(1, disS, 1);
  Dijkstra(n, disT, 2);
  Build(1, 1, path_cnt);
  for (int i = 1; i <= m; ++i)
    if (ind[i] == -1) {
      Update(1, 1, path_cnt, l[oe[i].u] + 1, r[oe[i].v],
             disS[oe[i].u] + oe[i].len + disT[oe[i].v]);
      Update(1, 1, path_cnt, l[oe[i].v] + 1, r[oe[i].u],
             disS[oe[i].v] + oe[i].len + disT[oe[i].u]);
    }
  for (int i = 1; i <= q; ++i) {
    int Edge_id;
    long long New_len, ans = disS[n];
    cin >> Edge_id >> New_len;
    if (ind[Edge_id] != -1) {
      ans = disS[n] - oe[Edge_id].len + New_len;
      if (New_len > oe[Edge_id].len)
        ans = min(ans, Query(1, 1, path_cnt, ind[Edge_id]));
    } else if (New_len < oe[Edge_id].len) {
      ans = min(ans, disS[oe[Edge_id].u] + New_len + disT[oe[Edge_id].v]);
      ans = min(ans, disS[oe[Edge_id].v] + New_len + disT[oe[Edge_id].u]);
    }
    cout << ans << endl;
  }
  return 0;
}
