#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
using namespace std;
int m(vector<int>& w) {
    unordered_map<int, int> c;

    for (int x : w) {
        c[x]++;
    }

    int p = 0;

    for (const auto& [l, q] : c) {
        int t = q;
        unordered_map<int, int> u;

        for (const auto& [a, b] : c) {
            if (a < l) {
                int f = l - a;
                if (c.find(f) != c.end() && u[a] < b && u[f] < c[f]) {
                    int r = min(b - u[a], c[f] - u[f]);
                    t += r;
                    u[a] += r;
                    u[f] += r;
                }
            }
        }

        p = max(p, t);
    }

    return p;
}

#define ll long 
void dfs(int node,vector<vector<ll>> &g,vector<bool> &vis,vector<ll> &index,vector<ll> &ds,vector<int> &container){
    vis[node]=1;
    index.push_back(node);
    ds.push_back(container[node]);

    for(auto &it: g[node]){
        if(!vis[it]){
            dfs(it,g,vis,index,ds,container);
        }
    }
}
vector<int> ss(vector<int> &container,vector<int> &firstIndex,vector<int> &secondIndex,vector<int> &slides){
    ll n=container.size();
    ll m=firstIndex.size();
    vector<vector<ll>> g(n);
    for(ll i=0;i<m;i++){
        ll l=firstIndex[i]-slides[i];
        l=l+1000000000*n;
        l%=n;
        ll r=secondIndex[i]+slides[i];
        r%=n;
        g[l].push_back(r);
        g[r].push_back(l);
    }
    vector<bool> vis(n);
    vector<int> ans(n);
    for(ll i=0;i<n;i++){
        vector<ll> index;
        vector<ll> ds;
        if(!vis[i]){
            dfs(i,g,vis,index,ds,container);
        }
        if(index.empty())continue;
        sort(index.begin(),index.end());
        sort(ds.begin(),ds.end(),greater<ll>());

        for(ll i=0;i<index.size();i++){
            ans[index[i]]=ds[i];
        }
    }
    return ans;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
long long factorial(int n) {
    long long result = 1;
    for (int i = 1; i <= n; ++i) {
        result *= i;
    }
    return result;
}
long long combinations(int n, int r) {
    if (r > n || r < 0) return 0;
    return factorial(n) / (factorial(r) * factorial(n - r));
}

int countTeams(vector<int> skills, int minPlayers, int minLevel, int maxLevel) {
    vector<int> f;
    for (int skill : skills) {
        if (skill >= minLevel && skill <= maxLevel) {
            f.push_back(skill);
        }
    }

    int v = f.size();
    long long totalTeams = 0;
    for (int i = minPlayers; i <= v; ++i) {
        totalTeams += combinations(v, i);
    }
    return totalTeams;
}