```go
package main

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

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

	var N, K, G1, G2, G3 int
	fmt.Fscan(in, &N, &K, &G1, &G2, &G3)
	var s string
	fmt.Fscan(in, &s)

	segments := []int{}
	curr := 0
	for i := 0; i < N; i++ {
		if s[i] == '#' {
			segments = append(segments, curr)
			curr = 0
		} else {
			curr++
		}
	}
	segments = append(segments, curr)

	const INF int64 = -1e18
	dp := make([][2]int64, K+1)
	for k := 0; k <= K; k++ {
		dp[k][0] = INF
		dp[k][1] = INF
	}
	dp[0][0] = 0

	for idx, L := range segments {
		newDp := make([][2]int64, K+1)
		for k := 0; k <= K; k++ {
			newDp[k][0] = INF
			newDp[k][1] = INF
		}
		isLast := (idx == len(segments)-1)
		for k := 0; k <= K; k++ {
			for bIn := 0; bIn <= 1; bIn++ {
				if dp[k][bIn] == INF {
					continue
				}
				maxBOut := 1
				if isLast {
					maxBOut = 0
				}
				for bOut := 0; bOut <= maxBOut; bOut++ {
					M := L - bIn - bOut
					if M < 0 {
						continue
					}
					addG3 := int64(0)
					if bOut == 1 {
						addG3 = int64(G3)
					}
					if G1 > G2 {
						t := M
						if K-k < t {
							t = K - k
						}
						val := int64(t*G1) + int64((M-t)/2)*int64(G2) + addG3
						nk := k + t
						if nk <= K {
							if newDp[nk][bOut] < dp[k][bIn]+val {
								newDp[nk][bOut] = dp[k][bIn] + val
							}
						}
					} else {
						// t = 0
						val0 := int64(M/2)*int64(G2) + addG3
						if newDp[k][bOut] < dp[k][bIn]+val0 {
							newDp[k][bOut] = dp[k][bIn] + val0
						}
						// t = 1 if M odd and G1 > 0
						if M%2 == 1 && G1 > 0 && k+1 <= K {
							val1 := int64(M/2)*int64(G2) + int64(G1) + addG3
							if newDp[k+1][bOut] < dp[k][bIn]+val1 {
								newDp[k+1][bOut] = dp[k][bIn] + val1
							}
						}
					}
				}
			}
		}
		dp = newDp
	}

	ans := int64(0)
	for k := 0; k <= K; k++ {
		if dp[k][0] > ans {
			ans = dp[k][0]
		}
	}
	fmt.Fprintln(out, ans)
}
```