```go
package main

import (
	"bufio"
	"container/heap"
	"fmt"
	"os"
)

type Int64Heap []int64

func (h Int64Heap) Len() int           { return len(h) }
func (h Int64Heap) Less(i, j int) bool { return h[i] < h[j] }
func (h Int64Heap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }

func (h *Int64Heap) Push(x interface{}) {
	*h = append(*h, x.(int64))
}

func (h *Int64Heap) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}

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

	var k1, k2, k3 int64
	var t1, t2, t3 int64
	var n int

	fmt.Fscan(in, &k1, &k2, &k3)
	fmt.Fscan(in, &t1, &t2, &t3)
	fmt.Fscan(in, &n)

	c := make([]int64, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(in, &c[i])
	}

	k1eff := n
	if k1 < int64(n) {
		k1eff = int(k1)
	}
	pq1 := make(Int64Heap, k1eff)
	for i := 0; i < k1eff; i++ {
		pq1[i] = 0
	}
	heap.Init(&pq1)

	end1 := make([]int64, n)
	for i := 0; i < n; i++ {
		avail := heap.Pop(&pq1).(int64)
		start := c[i]
		if avail > start {
			start = avail
		}
		finish := start + t1
		end1[i] = finish
		heap.Push(&pq1, finish)
	}

	k2eff := n
	if k2 < int64(n) {
		k2eff = int(k2)
	}
	pq2 := make(Int64Heap, k2eff)
	for i := 0; i < k2eff; i++ {
		pq2[i] = 0
	}
	heap.Init(&pq2)

	end2 := make([]int64, n)
	for i := 0; i < n; i++ {
		avail := heap.Pop(&pq2).(int64)
		start := end1[i]
		if avail > start {
			start = avail
		}
		finish := start + t2
		end2[i] = finish
		heap.Push(&pq2, finish)
	}

	k3eff := n
	if k3 < int64(n) {
		k3eff = int(k3)
	}
	pq3 := make(Int64Heap, k3eff)
	for i := 0; i < k3eff; i++ {
		pq3[i] = 0
	}
	heap.Init(&pq3)

	var ans int64 = 0
	for i := 0; i < n; i++ {
		avail := heap.Pop(&pq3).(int64)
		start := end2[i]
		if avail > start {
			start = avail
		}
		finish := start + t3
		wait := finish - c[i]
		if wait > ans {
			ans = wait
		}
		heap.Push(&pq3, finish)
	}

	fmt.Fprintln(out, ans)
}
```