<p>You are given two <strong>0-indexed</strong> integer arrays <code>nums1</code> and <code>nums2</code>, each of size <code>n</code>, and an integer <code>diff</code>. Find the number of <strong>pairs</strong> <code>(i, j)</code> such that:</p>

<ul>
	<li><code>0 &lt;= i &lt; j &lt;= n - 1</code> <strong>and</strong></li>
	<li><code>nums1[i] - nums1[j] &lt;= nums2[i] - nums2[j] + diff</code>.</li>
</ul>

<p>Return<em> the <strong>number of pairs</strong> that satisfy the conditions.</em></p>

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

<pre>
<strong>Input:</strong> nums1 = [3,2,5], nums2 = [2,2,1], diff = 1
<strong>Output:</strong> 3
<strong>Explanation:</strong>
There are 3 pairs that satisfy the conditions:
1. i = 0, j = 1: 3 - 2 &lt;= 2 - 2 + 1. Since i &lt; j and 1 &lt;= 1, this pair satisfies the conditions.
2. i = 0, j = 2: 3 - 5 &lt;= 2 - 1 + 1. Since i &lt; j and -2 &lt;= 2, this pair satisfies the conditions.
3. i = 1, j = 2: 2 - 5 &lt;= 2 - 1 + 1. Since i &lt; j and -3 &lt;= 2, this pair satisfies the conditions.
Therefore, we return 3.
</pre>

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

<pre>
<strong>Input:</strong> nums1 = [3,-1], nums2 = [-2,2], diff = -1
<strong>Output:</strong> 0
<strong>Explanation:</strong>
Since there does not exist any pair that satisfies the conditions, we return 0.
</pre>

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

<ul>
	<li><code>n == nums1.length == nums2.length</code></li>
	<li><code>2 &lt;= n &lt;= 10<sup>5</sup></code></li>
	<li><code>-10<sup>4</sup> &lt;= nums1[i], nums2[i] &lt;= 10<sup>4</sup></code></li>
	<li><code>-10<sup>4</sup> &lt;= diff &lt;= 10<sup>4</sup></code></li>
</ul>

class FenwickTree:
    def __init__(self, size):
        self.size = size
        self.tree = [0] * (size + 1)

    def update(self, index, value):
        while index <= self.size:
            self.tree[index] += value
            index += index & -index

    def query(self, index):
        result = 0
        while index > 0:
            result += self.tree[index]
            index -= index & -index
        return result

class Solution:
    def numberOfPairs(self, nums1: List[int], nums2: List[int], diff: int) -> int:
        n = len(nums1)
        
        # Calculate the differences and sort them
        differences = [nums1[i] - nums2[i] for i in range(n)]
        sorted_differences = sorted(set(differences))
        
        # Map the differences to their indices in the sorted list
        diff_to_index = {diff: i + 1 for i, diff in enumerate(sorted_differences)}
        
        # Initialize the Fenwick Tree
        fenwick_tree = FenwickTree(len(sorted_differences))
        
        result = 0
        for diff_j in differences:
            # Calculate the target difference
            target = diff_j + diff
            
            # Find the index of the target difference in the sorted list
            target_index = bisect.bisect_right(sorted_differences, target)
            
            # Query the Fenwick Tree to get the count of elements less than or equal to the target
            result += fenwick_tree.query(target_index)
            
            # Update the Fenwick Tree with the current difference
            fenwick_tree.update(diff_to_index[diff_j], 1)
        
        return result

# Example usage:
solution = Solution()
nums1 = [3, 2, 5]
nums2 = [2, 2, 1]
diff = 1
print(solution.numberOfPairs(nums1, nums2, diff))  # Output: 3

nums1 = [3, -1]
nums2 = [-2, 2]
diff = -1
print(solution.numberOfPairs(nums1, nums2, diff))  # Output: 0
35000