#include <bits/stdc++.h>

int64_t solve(const int s, const int r, const std::vector<int>& nums) {
    const int m = nums.size();
    const int s1 = (s + r) / 2;
    const int s2 = (s - r) / 2;
    const int mod = 1e9 + 7;
    
    auto is_odd = [](int val) -> int {
        return val & 1;
    };
        
    auto mod_add = [&](int64_t& u, int64_t v) -> void {
        u = (u + v) % mod;  
    };
    
    if (is_odd(s + r) || is_odd(s - r) || s2 < 0)
        return 0;
    
    //it can't exceed s1
    std::vector<std::vector<int64_t>> dp(m + 1, std::vector<int64_t>(s1 + 1, 0));
    dp[0][0] = 1;
    
    for (const auto val : nums)
        for (int len = m - 1; len >= 0; --len)
            for (int sum = s1 - val; sum >= 0; --sum)
                mod_add(dp[len + 1][sum + val], dp[len][sum]);
                
    int64_t ans = 0;
    for (int len = 1; len <= m; ++len)
        mod_add(ans, dp[len][s1] * dp[len][s2] % mod);
        
    return ans;
}

int main () {
    
    int m;
    int s, r;
    
    std::cin >> m >> s >> r;
    
    std::vector<int> nums(m);
    for (auto& val : nums)
        std::cin >> val;
        
    auto ans = solve(s, r, nums);
    std::cout << ans << "\n";
    
    return 0;
}