<p>Given an integer array <code>nums</code> and two integers <code>lower</code> and <code>upper</code>, return <em>the number of range sums that lie in</em> <code>[lower, upper]</code> <em>inclusive</em>.</p>

<p>Range sum <code>S(i, j)</code> is defined as the sum of the elements in <code>nums</code> between indices <code>i</code> and <code>j</code> inclusive, where <code>i &lt;= j</code>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> nums = [-2,5,-1], lower = -2, upper = 2
<strong>Output:</strong> 3
<strong>Explanation:</strong> The three ranges are: [0,0], [2,2], and [0,2] and their respective sums are: -2, -1, 2.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> nums = [0], lower = 0, upper = 0
<strong>Output:</strong> 1
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
	<li><code>-2<sup>31</sup> &lt;= nums[i] &lt;= 2<sup>31</sup> - 1</code></li>
	<li><code>-10<sup>5</sup> &lt;= lower &lt;= upper &lt;= 10<sup>5</sup></code></li>
	<li>The answer is <strong>guaranteed</strong> to fit in a <strong>32-bit</strong> integer.</li>
</ul>

class Solution {
public:
#define ll long long int
void merge(ll low,ll mid,ll high,vector<ll>& pf,ll lower,ll upper, ll& count)
{
    vector<ll>left(mid-low+1),right(high-(mid+1)+1);
    for(ll i=low;i<=mid;i++)
    {
        ll sum=pf[mid];
        if(i)
        sum-=pf[i-1];
        
        left[i-low]=sum;
    }
    for(ll i=mid+1;i<=high;i++)
    {
        ll sum=pf[i];
        if(mid+1)
        sum-=pf[mid];
        right[i-(mid+1)]=sum;
    }

    sort(left.begin(),left.end());
    sort(right.begin(),right.end());
    
    ll l=right.size()-1;
    ll r=right.size()-1;

    int temp=0;
    for(ll i=0;i<left.size();i++)
    {
        while(r>=0 && left[i]+right[r]>upper)
        r--;
        while(l>=0 && left[i]+right[l]>=lower)
        l--;
        temp+=max(r-(l+1)+1,(ll)0);
    }
    count+=temp;
}

void mergeSort(ll low, ll high,vector<ll>& pf,ll lower,ll upper, ll& count)
{
    if(low >= high)
    {
        return;
    }
    ll mid = (low + high) >> 1;
    mergeSort(low, mid,pf,lower,upper,count);
    mergeSort(mid+1,high,pf,lower,upper,count);
    merge(low,mid,high,pf,lower,upper,count);
}
    int countRangeSum(vector<int>& num, int lowe, int uppe) {
        vector<ll>nums;
        for(auto i:num)
        nums.push_back(i);

        ll lower=lowe;
        ll upper=uppe;
        
        ll n=num.size();
        ll count=0;
        for(auto i:nums)
        {
            if(i>=lower && i<=upper)
            count++;
        }
        vector<ll>pf(n);
        pf[0]=nums[0];
        for(ll i=1;i<n;i++)
        pf[i]=nums[i]+pf[i-1];

        mergeSort(0,n-1,pf,lower,upper,count);
        return count;
    }
};
272378