I'm getting TLE on the last case. If I run the 16ms solution vs my solution on my local machine it doesn't perform much better than a few ms. Why would that be enough to cause TLE, especially for an O(n^3 log n) algorithm which is the best I think we are going to get out it.

```
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int target) {
vector<int>::iterator i,j,k,l,z;
vector<vector<int>> returnVector;
int tempTarget;
string s;
if(nums.size() < 4)
return returnVector;
unordered_set<string> found;
sort(nums.begin(), nums.end());
z = nums.end();
if(*(z-1)+*(z-2)+*(z-3)+*(z-4) < target)
return returnVector;
for(i = nums.begin(); i + 3 != z; i++)
{
if(*i+*(i+1)+*(i+2)+*(i+3)>target) break;
for(j = i + 1; j + 2 != z; j++)
{
if(target-*i-*j-*(z-1) > *(z-1)) continue;
l = z;
for(k = j + 1; k + 1 != l && k != l; k++)
{
tempTarget = target - *i - *j - *k;
if(tempTarget < *(k+1)) continue;
if(tempTarget > *(l-1)) continue;
l = lower_bound(k+1,l,tempTarget);
if(l != z && *l == tempTarget)
{
s = buildString(*i,*j,*k,tempTarget);
if(found.find(s) == found.end())
{
found.insert(s);
returnVector.push_back({*i,*j,*k,tempTarget});
}
}
}
}
}
return returnVector;
}
private:
string buildString(int i, int j, int k, int l)
{
vector<int> temp({i,j,k,l});
sort(temp.begin(), temp.end());
string s(to_string(i) + " " + to_string(j) + " " + to_string(k) + " " + to_string(l) + " ");
return s;
}
};
```