```go
package main

import (
	"io"
	"os"
	"strconv"
)

type FastScanner struct {
	data []byte
	idx  int
	n    int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data, n: len(data)}
}

func (fs *FastScanner) NextInt64() int64 {
	for fs.idx < fs.n && fs.data[fs.idx] <= ' ' {
		fs.idx++
	}
	sign := int64(1)
	if fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	var val int64
	for fs.idx < fs.n {
		c := fs.data[fs.idx]
		if c < '0' || c > '9' {
			break
		}
		val = val*10 + int64(c-'0')
		fs.idx++
	}
	return sign * val
}

type BIT struct {
	n    int
	pw   int
	tree []int64
}

func NewBIT(n int) BIT {
	pw := 1
	for pw<<1 <= n {
		pw <<= 1
	}
	return BIT{n: n, pw: pw, tree: make([]int64, n+2)}
}

func (b *BIT) Add(i int, delta int64) {
	for i <= b.n {
		b.tree[i] += delta
		i += i & -i
	}
}

func (b *BIT) Sum(i int) int64 {
	if i < 1 {
		return 0
	}
	if i > b.n {
		i = b.n
	}
	var s int64
	for i > 0 {
		s += b.tree[i]
		i -= i & -i
	}
	return s
}

func (b *BIT) Kth(k int64) int {
	idx := 0
	bit := b.pw
	for bit > 0 {
		next := idx + bit
		if next <= b.n && b.tree[next] < k {
			idx = next
			k -= b.tree[next]
		}
		bit >>= 1
	}
	return idx + 1
}

type Dim struct {
	n        int
	diff     []int64
	zeros    BIT
	c0       BIT
	c1       BIT
	c2       BIT
	c3       BIT
	totalCnt int64
}

func NewDim(n int) *Dim {
	return &Dim{
		n:     n,
		diff:  make([]int64, n+1),
		zeros: NewBIT(n + 1),
		c0:    NewBIT(n),
		c1:    NewBIT(n),
		c2:    NewBIT(n),
		c3:    NewBIT(n),
	}
}

func (d *Dim) addBlock(s int, sign int64) {
	x := int64(s)
	d.c0.Add(s, sign)
	d.c1.Add(s, sign*x)
	d.c2.Add(s, sign*x*x)
	d.c3.Add(s, sign*x*x*x)
	d.totalCnt += sign
}

func BuildDim(vals []int64) (*Dim, []int) {
	n := len(vals) - 1
	d := NewDim(n)
	d.zeros.Add(1, 1)
	d.zeros.Add(n+1, 1)
	prev := 0
	blocks := make([]int, 0)
	for i := 1; i < n; i++ {
		d.diff[i] = vals[i+1] - vals[i]
		if d.diff[i] == 0 {
			d.zeros.Add(i+1, 1)
			s := i - prev
			d.addBlock(s, 1)
			blocks = append(blocks, s)
			prev = i
		}
	}
	s := n - prev
	d.addBlock(s, 1)
	blocks = append(blocks, s)
	return d, blocks
}

func (d *Dim) QueryContribution(s int) int64 {
	lim := s - 1
	if lim > d.n {
		lim = d.n
	}
	f0 := d.c0.Sum(lim)
	f1 := d.c1.Sum(lim)
	f2 := d.c2.Sum(lim)
	f3 := d.c3.Sum(lim)
	x := int64(s)
	res := (-f3 + 3*x*f2 + (3*x+1)*f1) / 6
	if s <= d.n {
		suffixCnt := d.totalCnt - f0
		suffixSum := int64(d.n) - f1
		res += x * (x + 1) * (3*suffixSum - (x-1)*suffixCnt) / 6
	}
	return res
}

func (d *Dim) prevZero(p int) int {
	cnt := d.zeros.Sum(p)
	return d.zeros.Kth(cnt) - 1
}

func (d *Dim) nextZero(p int) int {
	cnt := d.zeros.Sum(p + 1)
	return d.zeros.Kth(cnt+1) - 1
}

func (d *Dim) updatePoint(p int, delta int64, other *Dim, ans *int64) {
	if p < 1 || p >= d.n || delta == 0 {
		return
	}
	oldZero := d.diff[p] == 0
	d.diff[p] += delta
	newZero := d.diff[p] == 0
	if oldZero == newZero {
		return
	}
	if oldZero {
		l := d.prevZero(p)
		r := d.nextZero(p)
		s1 := p - l
		s2 := r - p
		s := r - l
		*ans -= other.QueryContribution(s1)
		*ans -= other.QueryContribution(s2)
		*ans += other.QueryContribution(s)
		d.addBlock(s1, -1)
		d.addBlock(s2, -1)
		d.addBlock(s, 1)
		d.zeros.Add(p+1, -1)
	} else {
		l := d.prevZero(p)
		r := d.nextZero(p)
		s := r - l
		s1 := p - l
		s2 := r - p
		*ans -= other.QueryContribution(s)
		*ans += other.QueryContribution(s1)
		*ans += other.QueryContribution(s2)
		d.addBlock(s, -1)
		d.addBlock(s1, 1)
		d.addBlock(s2, 1)
		d.zeros.Add(p+1, 1)
	}
}

func main() {
	fs := NewFastScanner()
	n := int(fs.NextInt64())
	m := int(fs.NextInt64())
	q := int(fs.NextInt64())

	a := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		a[i] = fs.NextInt64()
	}
	b := make([]int64, m+1)
	for i := 1; i <= m; i++ {
		b[i] = fs.NextInt64()
	}

	A, blocksA := BuildDim(a)
	B, blocksB := BuildDim(b)

	var ans int64
	if len(blocksA) <= len(blocksB) {
		for _, s := range blocksA {
			ans += B.QueryContribution(s)
		}
	} else {
		for _, s := range blocksB {
			ans += A.QueryContribution(s)
		}
	}

	out := make([]byte, 0, (q+1)*24)
	out = strconv.AppendInt(out, ans, 10)
	out = append(out, '\n')

	for i := 0; i < q; i++ {
		t := int(fs.NextInt64())
		l := int(fs.NextInt64())
		r := int(fs.NextInt64())
		x := fs.NextInt64()

		if t == 1 {
			if l > 1 {
				A.updatePoint(l-1, x, B, &ans)
			}
			if r < n {
				A.updatePoint(r, -x, B, &ans)
			}
		} else {
			if l > 1 {
				B.updatePoint(l-1, x, A, &ans)
			}
			if r < m {
				B.updatePoint(r, -x, A, &ans)
			}
		}

		out = strconv.AppendInt(out, ans, 10)
		out = append(out, '\n')
	}

	os.Stdout.Write(out)
}
```