#include <bits/stdc++.h>
using LL = long long;
const LL inf = 1e16;
const int kN = 200000 + 5;
using Edge = std::pair<int, int>;
Edge e[kN << 1];
std::vector<int> edges[kN];
int n, m, q;
LL dist[2][kN];
int parent[2][kN];
int l[kN], r[kN];
int idx[kN];
bool in_path[kN];
void dijkstra(int source, LL* dist, int* parent, int* l) {
  std::priority_queue<std::pair<LL, int>> pq;
  std::fill(dist, dist + n, inf);
  parent[source] = -1;
  dist[source] = 0;
  pq.emplace(0, source);
  while (!pq.empty()) {
    LL tmp;
    int u;
    std::tie(tmp, u) = pq.top();
    pq.pop();
    if (-tmp != dist[u]) continue;
    for (int id : edges[u]) {
      int v, w;
      std::tie(v, w) = e[id];
      if (dist[v] > dist[u] + w) {
        dist[v] = dist[u] + w;
        parent[v] = u;
        pq.emplace(-dist[v], v);
      }
    }
    if (l != nullptr) {
      if (idx[u] != -1) {
        l[u] = idx[u];
      } else {
        std::pair<int, int> candy(0, -1);
        for (int id : edges[u]) {
          int v, w;
          std::tie(v, w) = e[id];
          if (!in_path[id >> 1] && dist[v] + w == dist[u])
            candy = std::max(candy, std::make_pair(w, l[v]));
        }
        if (candy.first != 0) {
          l[u] = candy.second;
        }
      }
    }
  }
}
struct SegmentTree {
  int get_id(int l, int r) { return l + r | l != r; }
  void init(int tot) { std::fill(t, t + tot + tot - 1, inf); }
  void update(int L, int R, LL val, int l, int r) {
    if (L <= l && r <= R) {
      t[get_id(l, r)] = std::min(t[get_id(l, r)], val);
      return;
    }
    int mid = l + r >> 1;
    if (L <= mid) update(L, R, val, l, mid);
    if (mid < R) update(L, R, val, mid + 1, r);
  }
  LL query(int p, int l, int r) {
    LL ret = t[get_id(l, r)];
    if (l == r) return ret;
    int mid = l + r >> 1;
    if (p <= mid) ret = std::min(ret, query(p, l, mid));
    if (mid < p) ret = std::min(ret, query(p, mid + 1, r));
    return ret;
  }
  LL t[kN << 1];
} sgt;
int main() {
  scanf("%d%d%d", &n, &m, &q);
  for (int i = 0; i < m; ++i) {
    int a, b, c;
    scanf("%d%d%d", &a, &b, &c);
    --a;
    --b;
    e[i << 1] = Edge{b, c};
    edges[a].emplace_back(i << 1);
    e[i << 1 | 1] = Edge{a, c};
    edges[b].emplace_back(i << 1 | 1);
  }
  std::fill(idx, idx + n, -1);
  std::fill(l, l + n, n + 1);
  std::fill(r, r + n, -1);
  dijkstra(n - 1, dist[1], parent[1], nullptr);
  std::vector<int> main_path;
  for (int u = 0; u != -1; u = parent[1][u]) {
    idx[u] = main_path.size();
    main_path.emplace_back(u);
  }
  for (int u = 0; u < n; ++u) {
    for (int id : edges[u]) {
      int v, w;
      std::tie(v, w) = e[id];
      if (idx[u] != -1 && idx[v] != -1 && idx[u] + 1 == idx[v] &&
          dist[1][v] + w == dist[1][u]) {
        in_path[id >> 1] = true;
      }
    }
  }
  dijkstra(0, dist[0], parent[0], l);
  dijkstra(n - 1, dist[1], parent[1], r);
  int tot = main_path.size();
  sgt.init(tot);
  for (int i = 0; i < m; ++i) {
    int a = e[i << 1].first;
    int b = e[i << 1 | 1].first;
    int w = e[i << 1].second;
    if (in_path[i]) continue;
    if (l[a] < r[b]) {
      sgt.update(l[a], r[b] - 1, dist[0][a] + w + dist[1][b], 0, tot - 1);
    }
    if (l[b] < r[a]) {
      sgt.update(l[b], r[a] - 1, dist[0][b] + w + dist[1][a], 0, tot - 1);
    }
  }
  while (q--) {
    int t, x;
    scanf("%d%d", &t, &x);
    --t;
    LL result = inf;
    int a = e[t << 1].first;
    int b = e[t << 1 | 1].first;
    int w = e[t << 1].second;
    if (idx[a] > idx[b]) std::swap(a, b);
    if (x > w) {
      if (in_path[t]) {
        result =
            std::min(dist[0][n - 1] + x - w, sgt.query(idx[a], 0, tot - 1));
      } else {
        result = dist[0][n - 1];
      }
    } else {
      result = std::min({dist[0][n - 1], dist[0][a] + x + dist[1][b],
                         dist[0][b] + x + dist[1][a]});
    }
    printf("%lld\n", result);
  }
}
