class UserMainCode(object):
    @classmethod
    def qualifyingScore(cls, total_scores, num_top_scores, scores, weights):
        weighted_scores = [score -weight for score, weight in zip(scores, weights)]
        weighted_scores.sort(reverse=True)
        top_scores_sum = sum(weighted_scores[:num_top_scores])
        if top_scores_sum >= 35:
            return f"Qualified {top_scores_sum}"
        else:
            return f"Disqualified {top_scores_sum}"

def sameElementCount(size, inputList):
    return sum(inputList[i] % 2 == 0 and inputList[i] == inputList[i + 1] for i in range(size - 1))

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int ss(int a, vector<int>& b, int c, int s) {
    sort(b.begin(), b.end());
    int count = 0;
    for (int i = 0; i < a; ++i) {
        int current_capacity = b[i];
                int low = c - current_capacity;
        int high = s - current_capacity;
        
        auto left_index = lower_bound(b.begin() + i + 1, b.end(), low);
        auto right_index = upper_bound(b.begin() + i + 1, b.end(), high);
        
        // Count valid pairs
        count += distance(left_index, right_index);
    }

    return count;
}

int main() {
    int a;  
    cin >> a;
    
    vector<int> b(a);
    for (int i = 0; i < a; ++i) {
        cin >> b[i];
    }
    
    int c, s; 
    cin >> c >> s;
    
    cout << ss(a, b, c, s) << endl;

    return 0;
}

#include <vector>
#include <string>
#include <algorithm>
#include <iostream>

using namespace std;

class node {
public:
    long long ind;
    char c;
    long long t; 

    node() {}

    node(long long ind, char c, long long t) {
        this->ind = ind;
        this->c = c;
        this->t = t;
    }
};

bool cmp(const node &a, const node &b) {
    return a.ind < b.ind;
}

vector<string> fun(int n, vector<pair<int, char>> messages) {
    vector<node> v(n);
    for (int i = 0; i < n; i++) {
        long long ind = messages[i].first;
        char c = messages[i].second;
        long long t = i; 
        node temp(ind, c, t);
        v[i] = temp;
    }

    sort(v.begin(), v.end(), cmp);

    vector<pair<long long, string>> check; 
    vector<string> ans;

    for (int i = 0; i < n; i++) {
        if (v[i].c == '*') {
            int j = i + 1;
            while (j < n && v[j].c != '*' && v[j - 1].ind + 1 == v[j].ind) j++;
            if (j < n && v[j].c == '*') {
                long long mx = 0; 
                string temp = "";
                for (int k = i + 1; k < j; k++) temp.push_back(v[k].c);
                for (int k = i; k <= j; k++) mx = max(mx, v[k].t);
                check.push_back({mx, temp});
            }
        }
    }

    sort(check.begin(), check.end(), [](const pair<long long, string> &a, const pair<long long, string> &b) {
        return a.first > b.first; 
    });

    for (const auto &entry : check) ans.push_back(entry.second);

    return ans;
}

int main() {
    vector<pair<int, char>> in = {{693232583, '*'}, {1, '*'}, {2, 'a'}, {693232585, '*'}, {3, '*'}, {693232584, 'w'}};
    int n = in.size();

    vector<string> result = fun(n, in);

    for (const string &str : result) {
        cout << str << endl;
    }

    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class Solution {
public:
    int minSideJumps(vector<int>& obstacles) {
        const int inf = 1 << 30;  
        vector<int> f(3, inf);    
        f[1] = 0;               

        for (int i = 0; i < obstacles.size(); ++i) {
            vector<int> new_f(3, inf);  
            for (int j = 0; j < 3; ++j) {
                if (obstacles[i] != j + 1) {
                    new_f[j] = min(f[j], min({f[(j + 1) % 3], f[(j + 2) % 3]}) + 1);
                }
            }
                        f = new_f;
        }
        return min({f[0], f[1], f[2]});
    }
};

#include <bits/stdc++.h>
using namespace std;
long long getMinimumTotalCost(vector<int>& weights, int k) {
    vector<int> adjSums;
    int n = weights.size();
    for (int i = 0; i < n - 1; i++) {
        adjSums.push_back(weights[i] + weights[i + 1]);
    }
    sort(adjSums.begin(), adjSums.end());
    long long minCost = weights[0] + weights[n - 1];
    for (int i = 0; i < k - 1; i++) {
        minCost += adjSums[i];
    }
    return minCost;
}