package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
)

type fastReader struct {
	buf  []byte
	pos  int
	tail int
	in   io.Reader
}

func newFastReader(r io.Reader) *fastReader {
	return &fastReader{
		buf: make([]byte, 1<<16),
		in:  r,
	}
}

func (r *fastReader) nextByte() byte {
	if r.pos >= r.tail {
		n, _ := r.in.Read(r.buf)
		if n == 0 {
			return 0
		}
		r.pos = 0
		r.tail = n
	}
	b := r.buf[r.pos]
	r.pos++
	return b
}

func (r *fastReader) nextInt() int {
	b := r.nextByte()
	for b <= 32 && b != 0 {
		b = r.nextByte()
	}
	if b == 0 {
		return 0
	}
	res := 0
	for b > 32 {
		res = res*10 + int(b-'0')
		b = r.nextByte()
	}
	return res
}

func (r *fastReader) nextInt64() int64 {
	b := r.nextByte()
	for b <= 32 && b != 0 {
		b = r.nextByte()
	}
	if b == 0 {
		return 0
	}
	var res int64
	for b > 32 {
		res = res*10 + int64(b-'0')
		b = r.nextByte()
	}
	return res
}

func min(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

type LazySegTree struct {
	minVal []int64
	lazy   []int64
	size   int
}

func NewLazySegTree(n int) *LazySegTree {
	return &LazySegTree{
		minVal: make([]int64, 4*n+4),
		lazy:   make([]int64, 4*n+4),
		size:   n,
	}
}

func (st *LazySegTree) build(node, l, r int, arr []int64) {
	if l == r {
		st.minVal[node] = arr[l]
		return
	}
	mid := (l + r) / 2
	st.build(2*node, l, mid, arr)
	st.build(2*node+1, mid+1, r, arr)
	st.minVal[node] = min(st.minVal[2*node], st.minVal[2*node+1])
}

func (st *LazySegTree) push(node int) {
	if st.lazy[node] != 0 {
		val := st.lazy[node]
		st.minVal[2*node] += val
		st.lazy[2*node] += val
		st.minVal[2*node+1] += val
		st.lazy[2*node+1] += val
		st.lazy[node] = 0
	}
}

func (st *LazySegTree) add(node, l, r, ql, qr int, val int64) {
	if ql <= l && r <= qr {
		st.minVal[node] += val
		st.lazy[node] += val
		return
	}
	st.push(node)
	mid := (l + r) / 2
	if ql <= mid {
		st.add(2*node, l, mid, ql, qr, val)
	}
	if qr > mid {
		st.add(2*node+1, mid+1, r, ql, qr, val)
	}
	st.minVal[node] = min(st.minVal[2*node], st.minVal[2*node+1])
}

type PointSegTree struct {
	minVal []int64
	size   int
}

func NewPointSegTree(n int) *PointSegTree {
	return &PointSegTree{
		minVal: make([]int64, 4*n+4),
		size:   n,
	}
}

func (st *PointSegTree) build(node, l, r int, arr []int64) {
	if l == r {
		st.minVal[node] = arr[l]
		return
	}
	mid := (l + r) / 2
	st.build(2*node, l, mid, arr)
	st.build(2*node+1, mid+1, r, arr)
	st.minVal[node] = min(st.minVal[2*node], st.minVal[2*node+1])
}

func (st *PointSegTree) update(node, l, r, idx int, val int64) {
	if l == r {
		st.minVal[node] = val
		return
	}
	mid := (l + r) / 2
	if idx <= mid {
		st.update(2*node, l, mid, idx, val)
	} else {
		st.update(2*node+1, mid+1, r, idx, val)
	}
	st.minVal[node] = min(st.minVal[2*node], st.minVal[2*node+1])
}

type Edge struct {
	to  int
	cap int64
}

func main() {
	reader := newFastReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	n := reader.nextInt()
	if n == 0 {
		return
	}
	m := reader.nextInt()
	q := reader.nextInt()

	x := make([]int64, n+1)
	y := make([]int64, n)
	y[0] = 0

	for i := 1; i < n; i++ {
		x[i] = reader.nextInt64()
		y[i] = reader.nextInt64()
	}
	x[n] = 0

	adj := make([][]Edge, n+1)
	for i := 0; i < m; i++ {
		u := reader.nextInt()
		v := reader.nextInt()
		cap := reader.nextInt64()
		adj[u] = append(adj[u], Edge{to: v, cap: cap})
	}

	stLazy := NewLazySegTree(n)
	stLazy.build(1, 0, n-1, y)

	M := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		for _, edge := range adj[i] {
			v := edge.to
			stLazy.add(1, 0, n-1, 0, v-1, edge.cap)
		}
		M[i] = stLazy.minVal[1]
	}

	ansArr := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		ansArr[i] = x[i] + M[i]
	}

	stPoint := NewPointSegTree(n)
	stPoint.build(1, 1, n, ansArr)

	fmt.Fprintln(out, stPoint.minVal[1])

	for i := 0; i < q; i++ {
		u := reader.nextInt()
		w := reader.nextInt64()
		x[u] = w
		stPoint.update(1, 1, n, u, x[u]+M[u])
		fmt.Fprintln(out, stPoint.minVal[1])
	}
}