<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>. A pair of integers <code>x</code> and <code>y</code> is called a <strong>strong</strong> pair if it satisfies the condition:</p>

<ul>
	<li><code>|x - y| &lt;= min(x, y)</code></li>
</ul>

<p>You need to select two integers from <code>nums</code> such that they form a strong pair and their bitwise <code>XOR</code> is the <strong>maximum</strong> among all strong pairs in the array.</p>

<p>Return <em>the <strong>maximum</strong> </em><code>XOR</code><em> value out of all possible strong pairs in the array</em> <code>nums</code>.</p>

<p><strong>Note</strong> that you can pick the same integer twice to form a pair.</p>

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

<pre>
<strong>Input:</strong> nums = [1,2,3,4,5]
<strong>Output:</strong> 7
<strong>Explanation:</strong> There are 11 strong pairs in the array <code>nums</code>: (1, 1), (1, 2), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5) and (5, 5).
The maximum XOR possible from these pairs is 3 XOR 4 = 7.
</pre>

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

<pre>
<strong>Input:</strong> nums = [10,100]
<strong>Output:</strong> 0
<strong>Explanation:</strong> There are 2 strong pairs in the array nums: (10, 10) and (100, 100).
The maximum XOR possible from these pairs is 10 XOR 10 = 0 since the pair (100, 100) also gives 100 XOR 100 = 0.
</pre>

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

<pre>
<strong>Input:</strong> nums = [500,520,2500,3000]
<strong>Output:</strong> 1020
<strong>Explanation:</strong> There are 6 strong pairs in the array nums: (500, 500), (500, 520), (520, 520), (2500, 2500), (2500, 3000) and (3000, 3000).
The maximum XOR possible from these pairs is 500 XOR 520 = 1020 since the only other non-zero XOR value is 2500 XOR 3000 = 636.
</pre>

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

<ul>
	<li><code>1 &lt;= nums.length &lt;= 5 * 10<sup>4</sup></code></li>
	<li><code>1 &lt;= nums[i] &lt;= 2<sup>20</sup> - 1</code></li>
</ul>

class Node:
    def __init__(self):

        self.isTerminal = False
        self.childMap = [None, None]

class Trie:
    def __init__(self):

        self.root = Node()

    def insert(self, x):

        temp = self.root
        for i in range(31, -1, -1):
            bit = (x>>i) &1
            if(temp.childMap[bit] == None):
                temp.childMap[bit] = Node()

            temp = temp.childMap[bit]
           
        temp.isTerminal = True
    
    def remove(self, x):

        def removeHelper(root, x, i):
            if(root == None):
                return root
            
            if(i == -1):
                root.isTerminal = False
                if(isEmpty(root) == True):
                    root = None
                return root
            
            bit = (x>>i) &1
            root.childMap[bit] = removeHelper(root.childMap[bit], x, i-1)

            if(isEmpty(root) == True and root.isTerminal == False):
                root = None

            return root

        def isEmpty(root):
            return root.childMap[0] == None and root.childMap[1] == None

        self.root = removeHelper(self.root, x, 31)

    def findMaximumXor(self, x):

        temp = self.root
        xorr = 0
        num = 0
        for i in range(31, -1, -1):
            bit = (x>>i) &1
            opp = 1-bit

            if((bit == 0 and temp.childMap[1] != None) or (bit == 1 and temp.childMap[0] == None)):
                num = (1<<i) | num

            if(temp.childMap[opp] != None):
                xorr = (1<<i) | xorr
                temp = temp.childMap[opp]
            else:
                temp = temp.childMap[bit]

        return xorr 

class Solution:
    def maximumStrongPairXor(self, nums: List[int]) -> int:
        
        t = Trie()
        j = 0
        xorr = 0

        nums.sort()

        for i in range(len(nums)):
            t.insert(nums[i])

            while(nums[j] *2 < nums[i]):
                t.remove(nums[j])
                j += 1

            xorr = max(xorr, t.findMaximumXor(nums[i]))

        return xorr
59300