Problem: 2063B - Subsequence Update
Language: C++20 (GCC 13-64)


Submission (verdict: Wrong answer on test 2):
#include<bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
#define ll long long
#define all(x) x.begin(),x.end()
#define vii vector<int> 
#define vll vector<ll>
#define rep(i,x,n) for(int i = x;i<n;i++)
#include <algorithm> 
using namespace std;
#include <numeric>
#define mod 1000000007
#ifndef ONLINE_JUDGE
#define debug(x) cerr<<#x<<"->"<<x<<endl;
#else
#define debug(x)
#endif
// using namespace __gnu_pbds;

// typedef tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag,
//              tree_order_statistics_node_update>
//     ordered_set;


/* -----------TRIE----------- 
class TrieNode{
    public:
        TrieNode* children[26];
        bool isEnd;
        TrieNode(){
            isEnd = false;
            for(auto &e:children)
                e = nullptr;
        }
};
class Trie{
    public:
        TrieNode* root = new TrieNode();
        void insert(string s){
            TrieNode* crawl = root;
            for(auto e:s){
                int i = e-'a';
                if(crawl->children[i] == nullptr){
                    crawl->children[i] = new TrieNode();
                }
                crawl = crawl->children[i];
            }
            crawl->isEnd = true;
        }
        bool search(string s){
            TrieNode* crawl = root;
            for(auto e:s){
                int i = e-'a';
                if(!crawl->children[i])
                    return false;
                crawl = crawl->children[i];
            }
            if(crawl && crawl->isEnd)
                return true;
            return false;
        }
        
};

*/
/* ---------DFS--------------
int dx[] = {0,0,1,-1};
int dy[] = {-1,1,0,0};
bool isSafe(int x, int y, int n, int m){
    return (x>=0&&x<n&&y>=0&&y<m);
}
void dfs(vector<vector<int>> &mat,int i,int j,vector<vector<bool>> &visited,int &count){
    visited[i][j] = true;
    count+=mat[i][j];
    for(int z = 0;z<4;z++){
        int x = dx[z]+i;
        int y = dy[z]+j;
        if(isSafe(x,y,mat.size(),mat[0].size()) && !visited[x][y]&&mat[x][y]>0){
            visited[x][y] = true;
            dfs(mat,x,y,visited,count);
        }
    }
}
*/
// void dfs(int v, int p,vector<vector<long long>> &mp,vector<long long> &arr) {
//     if (mp[v].size() == 1 && mp[v][0] == p) {
//         arr[v] = 1;
//     } else {
//         for (auto u : mp[v]) {
//             if (u != p) {
//                 dfs(u, v,mp,arr);
//                 arr[v] += arr[u];
//             }
//         }
//     }
// }

/*-----------------------DSU--------------------------------- */
// vector<pair<int,int>> parent(200009);
// void initialize(){
//     for(int i = 1;i<=parent.size();i++)
//         parent[i] = {i,1};
// }
// pair<int, int> find(int x){
//     if(parent[x].first == x)
//         return parent[x];
//     parent[x] = find(parent[x].first);
//     return parent[x];
// }
// void Union(int x, int y){
//     auto x1 = find(x);
//     auto y1 = find(y);
//     if(x1.first != y1.first){
//         // cout<<x<<"-"<<y<<" ";
//         // if(parent[x].second)
//         parent[x1.first].first = y;
//         parent[y1.first].second += parent[x1.first].second;
//     }
// }

// void dfs(unordered_map<int,vector<int>> mp,vector<int> &a,vector<bool> &visited,int i,int &mini){
//     visited[i] = true;
//     for(auto e:mp[i]){
//         if(!visited[e]){
//             visited[e] = true;
//             mini = min(mini,a[e]);
//             dfs(mp,a,visited,e,mini);
//         }
//     }
// }

// long long fact(long long n)
// {
//       if(n==0)
//       return 1;
//     long long res = 1;
//     for (long long i = 2; i <= n; i++)
//         res = res * i;
//     return res;
// }
// long long nCr(long long n, long long r)
// {
//     ll nume = fact(n);
//     ll deno = fact(r);
//     nume/=deno;
//     deno = fact(n-r);
//     nume/=deno;
//     return nume;
// }
// bool isSafe(int x, int y, int n, int m){
//     return (x>=0&&x<n&&y>=0&&y<m);
// }
// int lcs(string a, string b){
//     int m = a.size(),n = b.size();
//     int dp[m + 1][n + 1];
//     for (int i = 0; i <= m; i++) {
//         for (int j = 0; j <= n; j++) {
//             if (i == 0 || j == 0)
//                 dp[i][j] = 0; 
//             else if (a[i - 1] == b[j - 1])
//                 dp[i][j] = dp[i - 1][j - 1] + 1;
//             else
//                 dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
//         }
//     }
//     return dp[m][n];
// }

// void rev(string &s,int l,int r){
//     // cout<<l<<"&"<<r<<" ";
//     l--;
//     r--;
//     while(l<=r){
//         swap(s[l],s[r]);
//         l++;
//         r--;
//     }
// }
// ll gcd(ll a, ll b){  ll c = a % b;  while(c != 0)  {    a = b;    b = c;    c = a % b;  }  return b;}
// ll get_factorial(ll x){
//     ll ans = 1;
//     while(x>0){
//         ans*=x;
//         x--;
//     }
//     return ans;
// }
//only perfect squares have odd number of divisors...........
void findAns(){
    int n,l,r;
    cin>>n>>l>>r;

    vii arr(n);
    rep(i,0,n)
        cin>>arr[i];

    sort(all(arr));
    ll ans = 0;
    for(int i = 0;i<r-l+1;i++){
        ans+=arr[i];
    }
    cout<<ans<<endl;


}

int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    #ifndef ONLINE_JUDGE
    freopen("error.txt","w",stderr);
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);

    #endif


    int n ;
    cin>>n;
    // int x = n ;
    while(n--){
        findAns();
    } 
}