```go
package main

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

const MOD int64 = 1000000007
const INF = 1000000000

func main() {
	in := bufio.NewReader(os.Stdin)
	var n, k int
	fmt.Fscan(in, &n, &k)

	a, b := 0, 0
	for i := 0; i < n; i++ {
		var w int
		fmt.Fscan(in, &w)
		if w == 50 {
			a++
		} else {
			b++
		}
	}

	if k < 50 {
		fmt.Println(-1)
		fmt.Println(0)
		return
	}

	C := make([][]int64, 51)
	for i := 0; i <= 50; i++ {
		C[i] = make([]int64, 51)
		C[i][0] = 1
		for j := 1; j <= i; j++ {
			C[i][j] = (C[i-1][j-1] + C[i-1][j]) % MOD
		}
	}

	type State struct {
		i50, i100 int
		side      int
	}

	dist := make([][][]int, a+1)
	for i := 0; i <= a; i++ {
		dist[i] = make([][]int, b+1)
		for j := 0; j <= b; j++ {
			dist[i][j] = make([]int, 2)
			dist[i][j][0] = INF
			dist[i][j][1] = INF
		}
	}

	queue := make([]State, 0, (a+1)*(b+1)*2)
	dist[a][b][0] = 0
	queue = append(queue, State{a, b, 0})

	for len(queue) > 0 {
		curr := queue[0]
		queue = queue[1:]
		i, j, side := curr.i50, curr.i100, curr.side

		if side == 0 {
			for x := 0; x <= i; x++ {
				for y := 0; y <= j; y++ {
					if x == 0 && y == 0 {
						continue
					}
					if 50*x+100*y > k {
						continue
					}
					ni, nj := i-x, j-y
					if dist[ni][nj][1] > dist[i][j][0]+1 {
						dist[ni][nj][1] = dist[i][j][0] + 1
						queue = append(queue, State{ni, nj, 1})
					}
				}
			}
		} else {
			right50 := a - i
			right100 := b - j
			for x := 0; x <= right50; x++ {
				for y := 0; y <= right100; y++ {
					if x == 0 && y == 0 {
						continue
					}
					if 50*x+100*y > k {
						continue
					}
					ni, nj := i+x, j+y
					if dist[ni][nj][0] > dist[i][j][1]+1 {
						dist[ni][nj][0] = dist[i][j][1] + 1
						queue = append(queue, State{ni, nj, 0})
					}
				}
			}
		}
	}

	if dist[0][0][1] == INF {
		fmt.Println(-1)
		fmt.Println(0)
		return
	}

	ways := make([][][]int64, a+1)
	for i := 0; i <= a; i++ {
		ways[i] = make([][]int64, b+1)
		for j := 0; j <= b; j++ {
			ways[i][j] = make([]int64, 2)
		}
	}
	ways[a][b][0] = 1

	maxDist := dist[0][0][1]
	for d := 0; d <= maxDist; d++ {
		for i := 0; i <= a; i++ {
			for j := 0; j <= b; j++ {
				for side := 0; side < 2; side++ {
					if dist[i][j][side] != d {
						continue
					}
					currWays := ways[i][j][side]
					if currWays == 0 {
						continue
					}

					if side == 0 {
						for x := 0; x <= i; x++ {
							for y := 0; y <= j; y++ {
								if x == 0 && y == 0 {
									continue
								}
								if 50*x+100*y > k {
									continue
								}
								ni, nj := i-x, j-y
								if dist[ni][nj][1] == d+1 {
									add := currWays * C[i][x] % MOD * C[j][y] % MOD
									ways[ni][nj][1] = (ways[ni][nj][1] + add) % MOD
								}
							}
						}
					} else {
						right50 := a - i
						right100 := b - j
						for x := 0; x <= right50; x++ {
							for y := 0; y <= right100; y++ {
								if x == 0 && y == 0 {
									continue
								}
								if 50*x+100*y > k {
									continue
								}
								ni, nj := i+x, j+y
								if dist[ni][nj][0] == d+1 {
									add := currWays * C[right50][x] % MOD * C[right100][y] % MOD
									ways[ni][nj][0] = (ways[ni][nj][0] + add) % MOD
								}
							}
						}
					}
				}
			}
		}
	}

	fmt.Println(dist[0][0][1])
	fmt.Println(ways[0][0][1] % MOD)
}
```