```go
package main

import (
	"fmt"
	"sort"
)

type state struct {
	sum      int64
	stickers int
}

type combined struct {
	sum    int64
	counts [26]int64
}

func main() {
	var n, k int
	var S int64
	if _, err := fmt.Scan(&n, &k, &S); err != nil {
		return
	}

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

	var facts [19]int64
	facts[0] = 1
	for i := 1; i <= 18; i++ {
		facts[i] = facts[i-1] * int64(i)
	}

	leftA := a[:n/2]
	rightA := a[n/2:]

	leftStates := make([]state, 0, 1500000)
	var dfsLeft func(idx int, currentSum int64, currentStickers int)
	dfsLeft = func(idx int, currentSum int64, currentStickers int) {
		if currentStickers > k {
			return
		}
		if idx == len(leftA) {
			leftStates = append(leftStates, state{currentSum, currentStickers})
			return
		}
		dfsLeft(idx+1, currentSum, currentStickers)
		if currentSum+leftA[idx] <= S {
			dfsLeft(idx+1, currentSum+leftA[idx], currentStickers)
		}
		if leftA[idx] <= 18 && currentSum+facts[leftA[idx]] <= S {
			dfsLeft(idx+1, currentSum+facts[leftA[idx]], currentStickers+1)
		}
	}
	dfsLeft(0, 0, 0)

	sort.Slice(leftStates, func(i, j int) bool {
		return leftStates[i].sum < leftStates[j].sum
	})

	var left []combined
	if len(leftStates) > 0 {
		currSum := leftStates[0].sum
		var currCounts [26]int64
		currCounts[leftStates[0].stickers]++
		for i := 1; i < len(leftStates); i++ {
			if leftStates[i].sum == currSum {
				currCounts[leftStates[i].stickers]++
			} else {
				for j := 1; j <= 25; j++ {
					currCounts[j] += currCounts[j-1]
				}
				left = append(left, combined{currSum, currCounts})
				currSum = leftStates[i].sum
				currCounts = [26]int64{}
				currCounts[leftStates[i].stickers]++
			}
		}
		for j := 1; j <= 25; j++ {
			currCounts[j] += currCounts[j-1]
		}
		left = append(left, combined{currSum, currCounts})
	}

	find := func(target int64, maxStickers int) int64 {
		l, r := 0, len(left)-1
		for l <= r {
			m := l + (r-l)/2
			if left[m].sum == target {
				if maxStickers > 25 {
					maxStickers = 25
				}
				if maxStickers < 0 {
					return 0
				}
				return left[m].counts[maxStickers]
			} else if left[m].sum < target {
				l = m + 1
			} else {
				r = m - 1
			}
		}
		return 0
	}

	ans := int64(0)
	var dfsRight func(idx int, currentSum int64, currentStickers int)
	dfsRight = func(idx int, currentSum int64, currentStickers int) {
		if currentStickers > k {
			return
		}
		if idx == len(rightA) {
			rem := S - currentSum
			ans += find(rem, k-currentStickers)
			return
		}
		dfsRight(idx+1, currentSum, currentStickers)
		if currentSum+rightA[idx] <= S {
			dfsRight(idx+1, currentSum+rightA[idx], currentStickers)
		}
		if rightA[idx] <= 18 && currentSum+facts[rightA[idx]] <= S {
			dfsRight(idx+1, currentSum+facts[rightA[idx]], currentStickers+1)
		}
	}
	dfsRight(0, 0, 0)

	fmt.Println(ans)
}
```