```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)

func readInt() int64 {
	sc.Scan()
	x, _ := strconv.ParseInt(sc.Text(), 10, 64)
	return x
}

func main() {
	sc.Split(bufio.ScanWords)
	n := int(readInt())
	a := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		a[i] = readInt()
	}

	b := make([]int64, n+1)
	for i := 1; i < n; i++ {
		diff := a[i+1] - a[i]
		if diff > 0 {
			b[i] = diff
		}
	}
	b[n] = 0

	S := make([]int64, n+2)
	for i := n; i >= 1; i-- {
		S[i] = S[i+1] + b[i]
	}

	V := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		V[i] = a[i] + S[i]
	}

	bit := NewBIT(n)
	for i := 1; i <= n; i++ {
		bit.add(i, a[i])
		bit.add(i+1, -a[i])
	}

	seg := NewSegTree(V)
	M := seg.tree[1]
	fmt.Println(ceil2(M))

	q := int(readInt())
	for q > 0 {
		q--
		l := int(readInt())
		r := int(readInt())
		x := readInt()

		bit.add(l, x)
		bit.add(r+1, -x)
		seg.add(1, 1, n, l, r, x)

		if l > 1 {
			al := bit.query(l)
			alminus1 := bit.query(l - 1)
			old := b[l-1]
			newVal := al - alminus1
			if newVal < 0 {
				newVal = 0
			}
			delta := newVal - old
			if delta != 0 {
				b[l-1] = newVal
				seg.add(1, 1, n, 1, l-1, delta)
			}
		}

		if r < n {
			ar := bit.query(r)
			arplus1 := bit.query(r + 1)
			old := b[r]
			newVal := arplus1 - ar
			if newVal < 0 {
				newVal = 0
			}
			delta := newVal - old
			if delta != 0 {
				b[r] = newVal
				seg.add(1, 1, n, 1, r, delta)
			}
		}

		M = seg.tree[1]
		fmt.Println(ceil2(M))
	}
}

func ceil2(x int64) int64 {
	if x >= 0 {
		return (x + 1) / 2
	}
	return x / 2
}

type BIT struct {
	tree []int64
	n    int
}

func NewBIT(n int) *BIT {
	return &BIT{tree: make([]int64, n+2), n: n}
}

func (b *BIT) add(idx int, val int64) {
	for i := idx; i <= b.n; i += i & -i {
		b.tree[i] += val
	}
}

func (b *BIT) query(idx int) int64 {
	var sum int64
	for i := idx; i > 0; i -= i & -i {
		sum += b.tree[i]
	}
	return sum
}

type SegTree struct {
	tree []int64
	lazy []int64
	n    int
}

func NewSegTree(arr []int64) *SegTree {
	n := len(arr) - 1
	tree := make([]int64, 4*n)
	lazy := make([]int64, 4*n)
	st := &SegTree{tree: tree, lazy: lazy, n: n}
	if n > 0 {
		st.build(1, 1, n, arr)
	}
	return st
}

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

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

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

func max64(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}
```