#include <bits/stdc++.h>
using namespace std;
template <typename I>
void r(I& i) {
  i = 0;
  int c = getchar();
  for (; !isdigit(c); c = getchar())
    ;
  for (; isdigit(c); c = getchar()) i = i * 10 + (c - '0');
}
template <typename I>
inline I r() {
  I i;
  r(i);
  return i;
}
constexpr long long inf = 0x3f3f3f3f3f3f3f3fll;
using edge_id = size_t;
using node_id = size_t;
struct Edge {
  node_id u, v;
  long long w;
};
struct Edge2 {
  edge_id ref;
  node_id to;
  long long w;
};
struct State {
  node_id u;
  long long d;
};
struct SegTree {
  using size_type = size_t;
  using value_type = long long;
  vector<value_type> t;
  SegTree(size_type n) : t(n << 2, inf) {}
  void build(size_type k, size_type l, size_type r) {
    t[k] = inf;
    if (l != r) {
      auto m = (l + r) >> 1;
      build(k << 1, l, m);
      build(k << 1 | 1, m + 1, r);
    }
  }
  void update(size_type k, size_type l, size_type r, size_type ql, size_type qr,
              value_type v) {
    if (ql <= qr) {
      if (ql <= l && r <= qr) {
        t[k] = min(t[k], v);
        return;
      }
      auto m = (l + r) >> 1;
      if (ql <= m) update(k << 1, l, m, ql, qr, v);
      if (m < qr) update(k << 1 | 1, m + 1, r, ql, qr, v);
    }
  }
  value_type query(size_type k, size_type l, size_type r, size_type q) const {
    if (l == r) return t[k];
    auto m = (l + r) >> 1;
    return min(
        t[k], q <= m ? query(k << 1, l, m, q) : query(k << 1 | 1, m + 1, r, q));
  }
};
int main() {
  auto n = r<node_id>();
  auto m = r<edge_id>();
  auto q = r<int>();
  vector<Edge> e(m + 1);
  vector<vector<Edge2> > g(n + 1);
  for (edge_id i = 1; i <= m; ++i) {
    r(e[i].u);
    r(e[i].v);
    r(e[i].w);
    g[e[i].u].push_back({i, e[i].v, e[i].w});
    g[e[i].v].push_back({i, e[i].u, e[i].w});
  }
  priority_queue<State, vector<State>, bool (*)(const State&, const State&)>
      que([](const State& p1, const State& p2) { return p1.d > p2.d; });
  vector<edge_id> last(n + 1);
  {
    vector<long long> dis(n + 1, inf);
    que.push({n, dis[n] = 0});
    while (!que.empty()) {
      auto [u, _] = que.top();
      que.pop();
      for (auto [i, v, w] : g[u]) {
        if (dis[v] > dis[u] + w) {
          que.push({v, dis[v] = dis[u] + w});
          last[v] = i;
        }
      }
    }
  }
  int pcnt = 0;
  vector<edge_id> ind(m + 1, -1);
  vector<node_id> left(n + 1), right(n + 1);
  vector<bool> on(n + 1);
  {
    on[1] = true;
    left[1] = right[1] = 0;
    node_id cur = 1;
    while (cur != n) {
      auto j = last[cur];
      ++pcnt;
      ind[j] = pcnt;
      cur = e[j].u ^ e[j].v ^ cur;
      on[cur] = true;
      left[cur] = right[cur] = pcnt;
    }
  }
  vector<long long> dis_1(n + 1, inf), dis_n(n + 1, inf);
  {
    vector<long long>& dis = dis_1;
    que.push({1, dis[1] = 0});
    while (!que.empty()) {
      auto [u, _] = que.top();
      que.pop();
      for (auto [_, v, w] : g[u]) {
        if (dis[v] > dis[u] + w) {
          que.push({v, dis[v] = dis[u] + w});
          if (!on[v]) left[v] = left[u];
        }
      }
    }
  }
  {
    vector<long long>& dis = dis_n;
    dis[n] = 0;
    que.push({n, 0});
    while (!que.empty()) {
      auto [u, _] = que.top();
      que.pop();
      for (auto [i, v, w] : g[u]) {
        if (dis[v] > dis[u] + w) {
          que.push({v, dis[v] = dis[u] + w});
          if (!on[v]) right[v] = right[u];
        }
      }
    }
  }
  SegTree t(pcnt);
  for (edge_id i = 1; i <= m; ++i) {
    if (!~ind[i]) {
      auto [u, v, w] = e[i];
      t.update(1, 1, pcnt, left[u] + 1, right[v], dis_1[u] + w + dis_n[v]);
      t.update(1, 1, pcnt, left[v] + 1, right[u], dis_1[v] + w + dis_n[u]);
    }
  }
  while (q--) {
    auto i = r<edge_id>();
    auto nw = r<long long>();
    auto [u, v, w] = e[i];
    printf("%lld\n", ~ind[i]
                         ? min(dis_1[n] - w + nw,
                               nw > w ? t.query(1, 1, pcnt, ind[i]) : inf)
                         : min(dis_1[n], nw < w ? min(dis_1[u] + nw + dis_n[v],
                                                      dis_1[v] + nw + dis_n[u])
                                                : inf));
  }
  return 0;
}
