<p>Given an integer array <code>arr</code>, return <em>the number of distinct bitwise ORs of all the non-empty subarrays of</em> <code>arr</code>.</p>

<p>The bitwise OR of a subarray is the bitwise OR of each integer in the subarray. The bitwise OR of a subarray of one integer is that integer.</p>

<p>A <strong>subarray</strong> is a contiguous non-empty sequence of elements within an array.</p>

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

<pre>
<strong>Input:</strong> arr = [0]
<strong>Output:</strong> 1
<strong>Explanation:</strong> There is only one possible result: 0.
</pre>

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

<pre>
<strong>Input:</strong> arr = [1,1,2]
<strong>Output:</strong> 3
<strong>Explanation:</strong> The possible subarrays are [1], [1], [2], [1, 1], [1, 2], [1, 1, 2].
These yield the results 1, 1, 2, 1, 3, 3.
There are 3 unique values, so the answer is 3.
</pre>

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

<pre>
<strong>Input:</strong> arr = [1,2,4]
<strong>Output:</strong> 6
<strong>Explanation:</strong> The possible results are 1, 2, 3, 4, 6, and 7.
</pre>

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

<ul>
	<li><code>1 &lt;= arr.length &lt;= 5 * 10<sup>4</sup></code></li>
	<li><code>0 &lt;= arr[i] &lt;= 10<sup>9</sup></code></li>
</ul>

//    class Solution {
//    public:
//        int subarrayBitwiseORs(vector<int>& A) {
//        
//        // res contains distinct values
//        set<int> res;
//        
//        set<int> pre;
//        //pre.insert(0);
//        
//        for (int x : A) {
//            set<int> temp;
//            for (int y : pre) {
//            temp.insert(x | y);
//            }
//            temp.insert(x);
//            pre = temp;
//            res.insert(pre.begin(), pre.end());
//        }
//        
//        return res.size();
//        }
//     
//    };
//class Solution {
//    public:
//        int subarrayBitwiseORs(vector<int> A) {
//            vector<int> res;
//            int left = 0, right;
//            for (int a: A) {
//                right = res.size();
//                res.push_back(a);
//                for (int i = left; i < right; ++i) {
//                    if (res.back() != (res[i] | a)) {
//                        res.push_back(res[i] | a);
//                    }
//                }
//                left = right;
//            }
//            return unordered_set(res.begin(), res.end()).size();
//        }
//    };
class Solution {
    public:
    int subarrayBitwiseORs(vector<int> A) {
        unordered_set<int> res, cur, cur2;
        for (int i: A) {
            cur2 = {i};
            for (int j: cur) cur2.insert(i|j);
            for (int j: cur = cur2) res.insert(j);
        }
        return res.size();
    }
};
182912