package main

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

const LIM uint64 = 1000000000000000000

func gen(primes []uint64, idx int, cur uint64, res *[]uint64) {
	if idx == len(primes) {
		*res = append(*res, cur)
		return
	}
	p := primes[idx]
	v := cur
	for {
		gen(primes, idx+1, v, res)
		if v > LIM/p {
			break
		}
		v *= p
	}
}

func enough(a, b []uint64, x, k uint64) bool {
	j := len(b) - 1
	var cnt uint64
	for _, v := range a {
		limit := x / v
		for j >= 0 && b[j] > limit {
			j--
		}
		if j < 0 {
			break
		}
		cnt += uint64(j + 1)
		if cnt >= k {
			return true
		}
	}
	return false
}

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	var n int
	fmt.Fscan(in, &n)

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

	var k uint64
	fmt.Fscan(in, &k)

	var p1, p2 []uint64
	for i, p := range primes {
		if i%2 == 0 {
			p1 = append(p1, p)
		} else {
			p2 = append(p2, p)
		}
	}

	a := make([]uint64, 0, 1<<16)
	b := make([]uint64, 0, 1<<16)
	gen(p1, 0, 1, &a)
	gen(p2, 0, 1, &b)

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

	if len(a) > len(b) {
		a, b = b, a
	}

	lo, hi := uint64(1), LIM
	for lo < hi {
		mid := lo + (hi-lo)/2
		if enough(a, b, mid, k) {
			hi = mid
		} else {
			lo = mid + 1
		}
	}

	fmt.Fprintln(out, lo)
}