#include <bits/stdc++.h>
const uint64_t LINF = 1ULL << 60;
const uint32_t INF = 1.1e9;
template <size_t N>
class MinSegmentTree {
 private:
  int32_t lazy[N];
  int32_t val[2 * N];
  int32_t lazyLvl;
  inline void update_node(uint32_t n, int32_t v) {
    val[n] += v;
    if (n < N) {
      lazy[n] += v;
    }
  }
  inline void recalc_node(uint32_t n) {
    val[n] = std::min(val[2 * n], val[2 * n + 1]) + lazy[n];
  }
  void push_updates(uint32_t n) {
    for (n >>= 1; n > 0; n >>= 1) {
      recalc_node(n);
    }
  }
  void push_lazy(uint32_t n) {
    for (uint32_t i = lazyLvl; i > 0; i--) {
      uint32_t cur = n >> i;
      if (cur == 0) {
        continue;
      }
      update_node(cur * 2, lazy[cur]);
      update_node(cur * 2 + 1, lazy[cur]);
      lazy[cur] = 0;
    }
  }

 public:
  MinSegmentTree() {
    uint32_t t = 2 * N - 1;
    while (t > 0) {
      lazyLvl++;
      t >>= 1;
    }
    lazyLvl--;
  }
  void set_val(uint32_t n, int32_t v) {
    n += N;
    val[n] = v;
    push_updates(n);
  }
  void update(uint32_t l, uint32_t r, int32_t v) {
    uint32_t oL = l += N;
    uint32_t oR = r += N;
    for (; l < r; l >>= 1, r >>= 1) {
      if (l & 1) {
        update_node(l++, v);
      }
      if (r & 1) {
        update_node(--r, v);
      }
    }
    push_updates(oL);
    push_updates(oR - 1);
  }
  int32_t query(uint32_t l, uint32_t r) {
    l += N;
    r += N;
    push_lazy(l);
    push_lazy(r - 1);
    int32_t ans = INF;
    for (; l < r; l >>= 1, r >>= 1) {
      if (l & 1) {
        ans = std::min(val[l++], ans);
      }
      if (r & 1) {
        ans = std::min(val[--r], ans);
      }
    }
    return ans;
  }
};
struct Val {
  uint64_t out;
  uint64_t through;
  Val(uint64_t pOut = 0, uint64_t pThrough = LINF)
      : out(pOut), through(pThrough) {}
  static Val combine(const Val &v1, const Val &v2) {
    Val ans;
    ans.out = v1.out;
    uint64_t c = v1.through;
    ans.out += std::min(c, v2.out);
    c -= std::min(c, v2.out);
    ans.through = std::min(c, v2.through);
    return ans;
  }
};
template <size_t N>
class ValSegmentTree {
 private:
  Val val[2 * N];

 public:
  void update(uint32_t n, Val v) {
    n += N;
    val[n] = v;
    for (n >>= 1; n > 0; n >>= 1) {
      val[n] = Val::combine(val[n * 2], val[n * 2 + 1]);
    }
  }
  uint64_t query(uint32_t l, uint32_t r) {
    Val lAns, rAns;
    for (l += N, r += N; l < r; l >>= 1, r >>= 1) {
      if (l & 1) {
        lAns = Val::combine(lAns, val[l++]);
      }
      if (r & 1) {
        rAns = Val::combine(val[--r], rAns);
      }
    }
    return Val::combine(lAns, rAns).out;
  }
};
const uint32_t MAX_N = 2e5 + 12;
MinSegmentTree<MAX_N> rTree;
ValSegmentTree<MAX_N> lTree;
uint64_t out[MAX_N];
uint64_t through[MAX_N];
std::vector<std::pair<uint32_t, int32_t>> edges[MAX_N];
uint32_t n, qCnt;
void input() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
  uint32_t eCnt;
  std::cin >> n >> eCnt >> qCnt;
  for (uint32_t i = 1; i < n; i++) {
    uint32_t r;
    std::cin >> through[i - 1] >> r;
    rTree.set_val(i - 1, r);
  }
  rTree.set_val(n - 1, INF);
  through[n - 1] = LINF;
  for (uint32_t i = 0; i < eCnt; i++) {
    uint32_t a, b, w;
    std::cin >> a >> b >> w;
    edges[a - 1].push_back(std::make_pair(b - 1, w));
  }
}
void precalc() {
  for (uint32_t i = 0; i < n; i++) {
    for (auto j : edges[i]) {
      int32_t cur = rTree.query(j.first, n);
      if (cur > j.second) {
        cur = j.second;
      }
      out[i] += cur;
      if (j.first + 1 < n) {
        rTree.update(j.first, n, -cur);
      }
    }
    lTree.update(i, Val(out[i], through[i]));
  }
}
int main() {
  input();
  precalc();
  std::cout << lTree.query(0, n) << "\n";
  for (uint32_t i = 0; i < qCnt; i++) {
    uint32_t ind, cap;
    std::cin >> ind >> cap;
    ind--;
    through[ind] = cap;
    lTree.update(ind, Val(out[ind], through[ind]));
    std::cout << lTree.query(0, n) << "\n";
  }
}
