package main

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

type FastScanner struct {
	r *bufio.Reader
}

func NewFastScanner() *FastScanner {
	return &FastScanner{r: bufio.NewReader(os.Stdin)}
}

func (fs *FastScanner) nextInt() int {
	sign := 1
	val := 0
	c, _ := fs.r.ReadByte()
	for (c < '0' || c > '9') && c != '-' {
		c, _ = fs.r.ReadByte()
	}
	if c == '-' {
		sign = -1
		c, _ = fs.r.ReadByte()
	}
	for c >= '0' && c <= '9' {
		val = val*10 + int(c-'0')
		c, _ = fs.r.ReadByte()
	}
	return sign * val
}

func lastWordMask(cap int) uint64 {
	rem := cap & 63
	if rem == 63 {
		return ^uint64(0)
	}
	return (uint64(1) << uint(rem+1)) - 1
}

func orShiftInPlace(dp []uint64, shift int, cap int, lastMask uint64) {
	if shift <= 0 {
		return
	}
	L := len(dp)
	o := shift >> 6
	b := uint(shift & 63)
	if o >= L {
		return
	}
	if b == 0 {
		for i := L - 1; i >= 0; i-- {
			s := i - o
			if s >= 0 {
				dp[i] |= dp[s]
			}
		}
	} else {
		for i := L - 1; i >= 0; i-- {
			s := i - o
			if s >= 0 {
				var val uint64 = dp[s] << b
				if s-1 >= 0 {
					val |= dp[s-1] >> (64 - b)
				}
				dp[i] |= val
			}
		}
	}
	dp[L-1] &= lastMask
}

func anyInRange(dp []uint64, l, r int) bool {
	if l > r {
		return false
	}
	startW := l >> 6
	endW := r >> 6
	startB := uint(l & 63)
	endB := uint(r & 63)
	if startW == endW {
		var upMask uint64
		if endB == 63 {
			upMask = ^uint64(0)
		} else {
			upMask = (uint64(1) << (endB + 1)) - 1
		}
		var lowMask uint64
		if startB == 0 {
			lowMask = 0
		} else {
			lowMask = (uint64(1) << startB) - 1
		}
		mask := upMask & ^lowMask
		return (dp[startW] & mask) != 0
	}
	// first word
	var firstMask uint64
	if startB == 0 {
		firstMask = ^uint64(0)
	} else {
		firstMask = ^((uint64(1) << startB) - 1)
	}
	if (dp[startW] & firstMask) != 0 {
		return true
	}
	// middle words
	for w := startW + 1; w < endW; w++ {
		if dp[w] != 0 {
			return true
		}
	}
	// last word
	var lastMask uint64
	if endB == 63 {
		lastMask = ^uint64(0)
	} else {
		lastMask = (uint64(1) << (endB + 1)) - 1
	}
	return (dp[endW] & lastMask) != 0
}

func main() {
	in := NewFastScanner()
	n := in.nextInt()
	l := in.nextInt()
	r := in.nextInt()

	a := make([]int, n)
	S := 0
	for i := 0; i < n; i++ {
		a[i] = in.nextInt()
		S += a[i]
	}

	b := make([]int, n)
	for i := 0; i < n; i++ {
		b[i] = in.nextInt()
	}

	if r > S {
		r = S
	}

	cnt := make([]int, S+1)
	impCnt := make([]int, S+1)
	for i := 0; i < n; i++ {
		cnt[a[i]]++
		if b[i] == 1 {
			impCnt[a[i]]++
		}
	}

	weightsAll := make([]int, 0)
	targetWeights := make([]int, 0)
	for w := 1; w <= S; w++ {
		if cnt[w] > 0 {
			weightsAll = append(weightsAll, w)
			if impCnt[w] > 0 {
				targetWeights = append(targetWeights, w)
			}
		}
	}

	good := make([]bool, S+1)

	for _, wt := range targetWeights {
		cap := r
		if cap > S-wt {
			cap = S - wt
		}
		if cap < l {
			good[wt] = false
			continue
		}
		L := (cap >> 6) + 1
		dp := make([]uint64, L)
		dp[0] = 1
		mask := lastWordMask(cap)

		if l == 0 {
			good[wt] = true
			continue
		}

		found := false
	outer:
		for _, v := range weightsAll {
			c := cnt[v]
			if v == wt {
				c--
			}
			if c <= 0 {
				continue
			}
			rem := c
			k := 1
			for rem > 0 {
				use := k
				if use > rem {
					use = rem
				}
				shift := v * use
				if shift <= cap {
					orShiftInPlace(dp, shift, cap, mask)
					if anyInRange(dp, l, cap) {
						found = true
						break outer
					}
				}
				rem -= use
				k <<= 1
			}
		}
		if !found {
			good[wt] = anyInRange(dp, l, cap)
		} else {
			good[wt] = true
		}
	}

	ans := 0
	for i := 0; i < n; i++ {
		if b[i] == 1 && good[a[i]] {
			ans++
		}
	}
	out := bufio.NewWriter(os.Stdout)
	fmt.Fprintln(out, ans)
	out.Flush()
}