```go
package main

import (
	"bufio"
	"io"
	"math/bits"
	"os"
	"strconv"
)

func nextUint(data []byte, idx *int) uint64 {
	n := len(data)
	for *idx < n && (data[*idx] < '0' || data[*idx] > '9') {
		*idx++
	}
	var x uint64
	for *idx < n && data[*idx] >= '0' && data[*idx] <= '9' {
		x = x*10 + uint64(data[*idx]-'0')
		*idx++
	}
	return x
}

func reaches(i uint64, rev []uint64, k uint64) bool {
	var sum uint64
	t := uint64(1)
	m := len(rev)

	for d, a := range rev {
		if a != 0 {
			rem := k - sum
			hi, lo := bits.Mul64(t, a)
			if hi != 0 || lo >= rem {
				return true
			}
			sum += lo
		}

		if t == k && d+1 < m {
			return true
		}

		if d+1 < m && t < k {
			num := i + uint64(d)
			den := uint64(d + 1)
			hi, lo := bits.Mul64(t, num)
			if hi >= den {
				t = k
			} else {
				q, _ := bits.Div64(hi, lo, den)
				if q >= k {
					t = k
				} else {
					t = q
				}
			}
		}
	}

	return false
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0

	n := int(nextUint(data, &idx))
	k := nextUint(data, &idx)

	a := make([]uint64, n)
	var maxv uint64
	left := n

	for i := 0; i < n; i++ {
		v := nextUint(data, &idx)
		a[i] = v
		if v > maxv {
			maxv = v
		}
		if v > 0 && left == n {
			left = i
		}
	}

	w := bufio.NewWriterSize(os.Stdout, 32)
	defer w.Flush()

	if maxv >= k {
		w.WriteString("0\n")
		return
	}

	m := n - left
	rev := make([]uint64, m)
	for i := 0; i < m; i++ {
		rev[i] = a[n-1-i]
	}

	l, r := uint64(1), k
	for l < r {
		mid := l + (r-l)/2
		if reaches(mid, rev, k) {
			r = mid
		} else {
			l = mid + 1
		}
	}

	w.WriteString(strconv.FormatUint(l, 10))
	w.WriteByte('\n')
}
```