```go
package main

import (
	"io"
	"os"
)

func main() {
	buf := make([]byte, 8192)
	var pos, length int
	var eof bool

	readChar := func() byte {
		if pos >= length {
			if eof {
				return 0
			}
			n, err := os.Stdin.Read(buf)
			if n == 0 || err != nil && err != io.EOF {
				eof = true
				return 0
			}
			pos = 0
			length = n
		}
		b := buf[pos]
		pos++
		return b
	}

	readInt := func() int {
		b := readChar()
		for b <= ' ' && b != 0 {
			b = readChar()
		}
		if b == 0 {
			return 0
		}
		sign := 1
		if b == '-' {
			sign = -1
			b = readChar()
		}
		res := 0
		for b > ' ' {
			res = res*10 + int(b-'0')
			b = readChar()
		}
		return res * sign
	}

	n := readInt()
	if n == 0 {
		return
	}
	m := readInt()
	k := readInt()
	q := readInt()

	head := make([]int, n+1)
	for i := range head {
		head[i] = -1
	}
	to := make([]int, 2*m)
	next := make([]int, 2*m)
	cap := make([]int, 2*m)
	flow := make([]int, 2*m)
	baseFlow := make([]int, 2*m)

	edgeCount := 0
	addEdge := func(u, v, c int) {
		to[edgeCount] = v
		cap[edgeCount] = c
		flow[edgeCount] = 0
		next[edgeCount] = head[u]
		head[u] = edgeCount
		edgeCount++

		to[edgeCount] = u
		cap[edgeCount] = 0
		flow[edgeCount] = 0
		next[edgeCount] = head[v]
		head[v] = edgeCount
		edgeCount++
	}

	for i := 0; i < m; i++ {
		u := readInt()
		v := readInt()
		c := readInt()
		addEdge(u, v, c)
	}

	d := make([]int, n+1)
	work := make([]int, n+1)
	vis := make([]uint32, n+1)
	var visId uint32 = 0
	qu := make([]int, n+1)

	bfs := func(S, T int) bool {
		visId++
		qu[0] = S
		headQ, tailQ := 0, 1
		vis[S] = visId
		d[S] = 0
		for headQ < tailQ {
			u := qu[headQ]
			headQ++
			for e := head[u]; e != -1; e = next[e] {
				v := to[e]
				if vis[v] != visId && cap[e] > flow[e] {
					vis[v] = visId
					d[v] = d[u] + 1
					qu[tailQ] = v
					tailQ++
					if v == T {
						return true
					}
				}
			}
		}
		return false
	}

	var dfs func(u, push int) int
	dfs = func(u, push int) int {
		if push == 0 || u == n {
			return push
		}
		for ; work[u] != -1; work[u] = next[work[u]] {
			e := work[u]
			v := to[e]
			if vis[v] == visId && d[v] == d[u]+1 && cap[e] > flow[e] {
				tr := push
				if cap[e]-flow[e] < tr {
					tr = cap[e] - flow[e]
				}
				pushed := dfs(v, tr)
				if pushed == 0 {
					continue
				}
				flow[e] += pushed
				flow[e^1] -= pushed
				return pushed
			}
		}
		return 0
	}

	baseMaxFlow := 0
	for bfs(1, n) {
		copy(work, head)
		for {
			pushed := dfs(1, 1000000000)
			if pushed == 0 {
				break
			}
			baseMaxFlow += pushed
		}
	}
	copy(baseFlow, flow)

	w := make([]int, k)
	outBytes := make([]byte, 0, 20*q)

	appendInt := func(val int) {
		if val == 0 {
			outBytes = append(outBytes, '0', '\n')
			return
		}
		var buf [20]byte
		p := 19
		for val > 0 {
			buf[p] = byte(val%10) + '0'
			val /= 10
			p--
		}
		outBytes = append(outBytes, buf[p+1:]...)
		outBytes = append(outBytes, '\n')
	}

	for i := 0; i < q; i++ {
		for j := 0; j < k; j++ {
			w[j] = readInt()
			cap[2*j] = w[j]
		}
		copy(flow, baseFlow)
		addFlow := 0
		for bfs(1, n) {
			copy(work, head)
			for {
				pushed := dfs(1, 1000000000)
				if pushed == 0 {
					break
				}
				addFlow += pushed
			}
		}
		appendInt(baseMaxFlow + addFlow)
		for j := 0; j < k; j++ {
			cap[2*j] = 0
		}
	}
	os.Stdout.Write(outBytes)
}
```