struct str_index
{
   size_t index;
   BSTR wstr;
   friend bool operator<(const str_index& l, const str_index& r);
   friend bool operator==(const str_index& l, const str_index& r);
   friend bool operator!=(const str_index& l, const str_index& r) { return !(l == r); }
   friend bool operator>(const str_index& l, const str_index& r);
};

bool operator<(const str_index& l, const str_index& r)
{
   if (l.wstr == nullptr) return false;// r.wstr != nullptr;
   if (r.wstr == nullptr) return true;
   return wcscmp(l.wstr, r.wstr) < 0;
}

bool operator==(const str_index& l, const str_index& r)
{
   return l.wstr == r.wstr ||
      l.wstr != nullptr && r.wstr != nullptr && wcscmp(l.wstr, r.wstr) == 0;
}

bool operator>(const str_index& l, const str_index& r)
{
   if (l.wstr == nullptr) return false;
   if (r.wstr == nullptr) return true;
   return wcscmp(l.wstr, r.wstr) > 0;
}

   bool comparestring1(BSTR lhs, BSTR rhs)    {
      if (lhs == NULL) return false;
      if (rhs == NULL) return true;
      return wcscmp(lhs, rhs) < 0;
   }
   bool comparestring2(BSTR lhs, BSTR rhs)    {
      if (lhs == NULL) return false;
      if (rhs == NULL) return true;
      return wcscmp(lhs, rhs) > 0;
   }

   bool comparestring3(BSTR lhs, BSTR rhs) {
      if (lhs == NULL && rhs == NULL) return true;
      if (lhs == NULL || rhs == NULL) return false;
      return wcscmp(lhs, rhs) == 0;
   }


STDMETHODIMP CVBA::ArraySortS(VARIANT* array_in_out, VARIANT_BOOL sort_order, LONG key_1, LONG key_2, LONG key_3, LONG sort_orientation, VARIANT_BOOL delete_duplicates, VARIANT_BOOL out_array_index, VARIANT* index_array_out)
{
   if (array_in_out->vt != 8200) { return E_INVALIDARG; }
   if (sort_orientation <0 || sort_orientation > 3) { return E_INVALIDARG; } //границы метода
   if (sort_orientation >1 && out_array_index) { return E_INVALIDARG; } //массив мндексов выводится для первых двух методов сортировки 
   long cDims = array_in_out->parray->cDims;
   if (cDims > 2) { return E_INVALIDARG; }
   long lLbound_0 = array_in_out->parray->rgsabound[0].lLbound;//нижняя граница 1х массив
   long cElements_0 = array_in_out->parray->rgsabound[0].cElements;//количество элементов 1х массив/2х массив - столбцов
   long lLbound_1 = 0;//нижняя граница 2х массив
   long cElements_1 = 0;//количество элементов 2х массив
   if (cDims == 2) {
      lLbound_1 = array_in_out->parray->rgsabound[1].lLbound;
      cElements_1 = array_in_out->parray->rgsabound[1].cElements;
   }
   if (key_1 < 1 || key_2 < 1 || key_3 < 1) { return E_INVALIDARG; }
   //if (key_1 > cElements_0 || key_2 > cElements_0 || key_3 > cElements_0) { return E_INVALIDARG; }
   //if (lLbound_0 < 0 || lLbound_1 < 0) { return E_INVALIDARG; } //если границы массивы ниже 0
   if (cDims == 2 && delete_duplicates) { return E_INVALIDARG; } //&&-и
   if(sort_orientation == 0) {
      if (key_1 > cElements_0) { return E_INVALIDARG; }
      if (key_2 > cElements_0) { return E_INVALIDARG; }
      if (key_3 > cElements_0) { return E_INVALIDARG; }
      if (out_array_index && delete_duplicates) { return E_INVALIDARG; } //&&-и
   }
   else if (sort_orientation == 1) {
      if (key_1 > cElements_1) { return E_INVALIDARG; } 
      if (key_2 > cElements_1) { return E_INVALIDARG; } 
      if (key_3 > cElements_1) { return E_INVALIDARG; } 
      if (out_array_index && delete_duplicates) { return E_INVALIDARG; } //&&-и
   }

   HRESULT hr; 
   BSTR HUGEP *pbstr;//в с-массив
   //hr = SafeArrayLock(array_in_out->parray); //hr = SafeArrayUnlock(array_in_out->parray)
   //if (FAILED(hr)) return hr;
   hr = SafeArrayAccessData(array_in_out->parray, (void HUGEP**)&pbstr); //открываем массив для редактирования
   if (FAILED(hr)) return hr;

   if (cDims == 1 && !out_array_index && !delete_duplicates) {  //если сортировать одномерный массив без вывода индексов и без удаления
      if (!sort_order) { concurrency::parallel_buffered_sort(pbstr, pbstr + cElements_0, comparestring1); }//0.21 сек
      else { concurrency::parallel_buffered_sort(pbstr, pbstr + cElements_0, comparestring2); }
      hr = SafeArrayUnaccessData(array_in_out->parray); //закрываем массив
      if (FAILED(hr)) return hr;
   }
   else if (cDims == 1 && !out_array_index){ //если одномерный массив и не выгружаем индексы, просто сортируем, удаляем
      if (!sort_order) { concurrency::parallel_buffered_sort(pbstr, pbstr + cElements_0, comparestring1); }
      else { concurrency::parallel_buffered_sort(pbstr, pbstr + cElements_0, comparestring2); }

      long x=0; //удаляем строки, что бы не текла память, нужно ли что-то еще?
      for (long i = 1; i < cElements_0; ++i)
      {
         if (comparestring3(pbstr[i],pbstr[x])) {
            SysFreeString(pbstr[i]); 
         }
         else { 
            pbstr[++x]=pbstr[i];   
         }
      }
      array_in_out->parray->rgsabound[0].cElements = x+1; //меняем количество элементов
      hr = SafeArrayUnaccessData(array_in_out->parray); //закрываем массив
      if (FAILED(hr)) return hr;

      hr = SafeArrayRedim(array_in_out->parray, &array_in_out->parray->rgsabound[0]); //удаляем лишние
      if (FAILED(hr)) return hr;
   }
   else if (cDims == 1) { //если одномерный массив с сортировкой, удалением и выгружаем индексы
      std::vector<str_index> pairs1(cElements_0);
      for (size_t i = 0; i < cElements_0; ++i) pairs1[i] = str_index{ i+ lLbound_0, pbstr[i] };
      if (!sort_order) {
         concurrency::parallel_buffered_sort(pairs1.begin(), pairs1.end());
      }
      else {
         concurrency::parallel_buffered_sort(pairs1.begin(), pairs1.end(),
            []( str_index & l, str_index & r)
         {return l > r; });
      }
      std::vector<long> out1(pairs1.size());
      std::transform(pairs1.begin(), pairs1.end(), out1.begin(), [](const str_index& i) { return i.index; });
      hr = SafeArrayUnaccessData(array_in_out->parray); //закрываем массив
      if (FAILED(hr)) return hr;
      CComSafeArray <long> outArray1(out1.size(), lLbound_0);
      for (long i = 0; i < out1.size(); i++) { (long)outArray1[i + lLbound_0] = out1[i]; }
      CComVariant varOut(outArray1);
      varOut.Detach(index_array_out);
      outArray1.Destroy();
   }
   else if (sort_orientation == 2) {//сортировка по всему двухмерному  массиву строка-столбец
      if (!sort_order) { concurrency::parallel_buffered_sort(pbstr, pbstr + cElements_0 * cElements_1, comparestring1); } //0.21 сек
      else { concurrency::parallel_buffered_sort(pbstr, pbstr + cElements_0 * cElements_1, comparestring2); }
      hr = SafeArrayUnaccessData(array_in_out->parray); //закрываем массив
      if (FAILED(hr)) return hr;
   } 
   else if (sort_orientation == 3) { ////сортировка по всему двухмерному массиву столбец-строка)
      long cElements_full = cElements_0 * cElements_1;
      std::vector <BSTR> vBSTR(pbstr, pbstr + cElements_full); //передаем в вектор
      if (!sort_order) concurrency::parallel_buffered_sort(vBSTR.begin(), vBSTR.end(), comparestring1); //0.23(0.30) сек
      else concurrency::parallel_buffered_sort(vBSTR.begin(), vBSTR.end(), comparestring2);

      long iTmp = 0;
      for (long i = 0; i < cElements_1; i++) {
         for (long j = 0; j < cElements_full; j=j+cElements_1) {
            pbstr[j+i] = vBSTR[iTmp++];//iTmp++;
         }
      }
      hr = SafeArrayUnaccessData(array_in_out->parray); //закрываем массив
      if (FAILED(hr)) return hr;
   } 
   else if ((key_2 == 1 && key_3 == 1)||((key_1 == key_2) && (key_2 == key_3))) { //если одно условие
      if (sort_orientation == 0) { //если сортировка по строкам
         //if (key_1 == 1) key_1 = lLbound_0;
         long offset = (key_1 - 1)*cElements_1; //сдвигаем на заданную размерность 
         std::vector<str_index> pairs2(cElements_1);
         for (size_t i = 0; i < cElements_1; ++i) pairs2[i] = str_index{ i, pbstr[i+ offset] }; //сдвигаем на заданную размерность 
         if (!sort_order) {
            concurrency::parallel_buffered_sort(pairs2.begin(), pairs2.end());
         }
         else {
            concurrency::parallel_buffered_sort(pairs2.begin(), pairs2.end(),
               [](str_index & l, str_index & r)
            {return l > r; });
         }
         std::vector<long> out2(pairs2.size());
         std::transform(pairs2.begin(), pairs2.end(), out2.begin(), [](const str_index& i) { return i.index; });
         if (out_array_index) { //выводим индексы
            CComSafeArray <long> outArray2(out2.size(), lLbound_1);
            for (long i = 0; i < out2.size(); i++) outArray2[i + lLbound_1] = out2[i]+ lLbound_1;
            CComVariant varOut(outArray2);
            varOut.Detach(index_array_out);
            outArray2.Destroy();
         }
         else { //сортируем двухмерный массив поодному из измерений (столбец - сортировка строк)
            long cElements_full2 = cElements_0 * cElements_1;
            std::vector <BSTR> vBSTR(pbstr, pbstr + cElements_full2); //передаем в вектор
            for (long i = 0; i < cElements_0; i++) {
               for (long j = 0; j < cElements_1; j++) {
                  pbstr[j + i * cElements_1] = vBSTR[out2[j] + i * cElements_1];
               }
            }
         }
         hr = SafeArrayUnaccessData(array_in_out->parray); //закрываем массив
         if (FAILED(hr)) return hr;
      }
      else if (sort_orientation == 1) { //если сортировка по столбцам
         //if (key_1 == -1) key_1 = lLbound_1;
         long offset = (key_1 - 1); //сдвигаем на заданную размерность 
         std::vector<str_index> pairs2(cElements_0);
         for (size_t i = 0; i < cElements_0; ++i) pairs2[i] = str_index{ i, pbstr[i*cElements_1 + offset] }; //сдвигаем на заданную размерность 
         if (!sort_order) {
            concurrency::parallel_buffered_sort(pairs2.begin(), pairs2.end());
         }
         else {
            concurrency::parallel_buffered_sort(pairs2.begin(), pairs2.end(),
               [](str_index & l, str_index & r)
            {return l > r; });
         }
         std::vector<long> out2(pairs2.size());
         std::transform(pairs2.begin(), pairs2.end(), out2.begin(), [](const str_index& i) { return i.index; });
         if (out_array_index) { //выводим индексы
            CComSafeArray <long> outArray2(out2.size(), lLbound_0);
            for (long i = 0; i < out2.size(); i++) outArray2[i + lLbound_0] = out2[i] + lLbound_0;
            CComVariant varOut(outArray2);
            varOut.Detach(index_array_out);
            outArray2.Destroy();
         }
         else { //сортируем двухмерный массив поодному из измерений (столбец - сортировка строк)
            long cElements_full2 = cElements_0 * cElements_1;
            std::vector <BSTR> vBSTR(pbstr, pbstr + cElements_full2); //передаем в вектор
            for (long i = 0; i < cElements_1; i++) {
               for (long j = 0; j < cElements_0; j++) {
                  pbstr[i + j * cElements_1] = vBSTR[out2[j] * cElements_1 + i];
               }
            }
         }
         hr = SafeArrayUnaccessData(array_in_out->parray); //закрываем массив
         if (FAILED(hr)) return hr;
      }
         
   }
   ///////////////////////////////////////////////////////////////////////////////////////////////
   else if ((key_2 > -1 || key_3 > -1)) { //если больше условий 
      if (sort_orientation == 0) { //если сортировка по строкам
         //if (key_1 == -1) key_1 = lLbound_0;
         long offset1 = (key_1 - 1)*cElements_1; //сдвигаем на заданную размерность 
         long offset2 = (key_2 - 1)*cElements_1; //сдвигаем на заданную размерность 
         long offset3 = (key_3 - 1)*cElements_1; //сдвигаем на заданную размерность 

         std::vector<str_index> pairs2(cElements_1);
         for (size_t i = 0; i < cElements_1; ++i) {
            _bstr_t BSTRtmp(pbstr[i + offset1]);
            BSTRtmp= BSTRtmp + _bstr_t(pbstr[i + offset2]);
            BSTRtmp = BSTRtmp + _bstr_t(pbstr[i + offset3]);
            pairs2[i] = str_index{ i, BSTRtmp};
         }
         if (!sort_order) {
            concurrency::parallel_buffered_sort(pairs2.begin(), pairs2.end());
         }
         else {
            concurrency::parallel_buffered_sort(pairs2.begin(), pairs2.end(),
               [](str_index & l, str_index & r)
            {return l > r; });
         }
         std::vector<long> out2(pairs2.size());
         std::transform(pairs2.begin(), pairs2.end(), out2.begin(), [](const str_index& i) { return i.index; });
         if (out_array_index) { //выводим индексы
            CComSafeArray <long> outArray2(out2.size(), lLbound_1);
            for (long i = 0; i < out2.size(); i++) outArray2[i + lLbound_1] = out2[i] + lLbound_1;
            CComVariant varOut(outArray2);
            varOut.Detach(index_array_out);
            outArray2.Destroy();
         }
         else { //сортируем двухмерный массив поодному из измерений (столбец - сортировка строк)
            long cElements_full2 = cElements_0 * cElements_1;
            std::vector <BSTR> vBSTR(pbstr, pbstr + cElements_full2); //передаем в вектор
            for (long i = 0; i < cElements_0; i++) {
               for (long j = 0; j < cElements_1; j++) {
                  pbstr[j + i * cElements_1] = vBSTR[out2[j] + i * cElements_1];
               }
            }
         }
         hr = SafeArrayUnaccessData(array_in_out->parray); //закрываем массив
         if (FAILED(hr)) return hr;
      }
      else if (sort_orientation == 1) { //если сортировка по столбцам
         //if (key_1 == -1) key_1 = lLbound_1;
         long offset1 = (key_1 - 1); //сдвигаем на заданную размерность 
         long offset2 = (key_2 - 1); //сдвигаем на заданную размерность 
         long offset3 = (key_3 - 1); //сдвигаем на заданную размерность 
         std::vector<str_index> pairs2(cElements_0);
         for (size_t i = 0; i < cElements_0; ++i) {
            _bstr_t BSTRtmp(pbstr[i*cElements_1 + offset1]);
            BSTRtmp = BSTRtmp + _bstr_t(pbstr[i*cElements_1 + offset2]);
            BSTRtmp = BSTRtmp + _bstr_t(pbstr[i*cElements_1 + offset3]);
            pairs2[i] = str_index{ i, BSTRtmp };
         }
         if (!sort_order) {
            concurrency::parallel_buffered_sort(pairs2.begin(), pairs2.end());
         }
         else {
            concurrency::parallel_buffered_sort(pairs2.begin(), pairs2.end(),
               [](str_index & l, str_index & r)
            {return l > r; });
         }
         std::vector<long> out2(pairs2.size());
         std::transform(pairs2.begin(), pairs2.end(), out2.begin(), [](const str_index& i) { return i.index; });
         if (out_array_index) { //выводим индексы
            CComSafeArray <long> outArray2(out2.size(), lLbound_0);
            for (long i = 0; i < out2.size(); i++) outArray2[i + lLbound_0] = out2[i] + lLbound_0;
            CComVariant varOut(outArray2);
            varOut.Detach(index_array_out);
            outArray2.Destroy();
         }
         else { //сортируем двухмерный массив по одному из измерений (столбец - сортировка строк)
            long cElements_full2 = cElements_0 * cElements_1;
            std::vector <BSTR> vBSTR(pbstr, pbstr + cElements_full2); //передаем в вектор
            for (long i = 0; i < cElements_1; i++) {
               for (long j = 0; j < cElements_0; j++) {
                  pbstr[i + j * cElements_1] = vBSTR[out2[j] * cElements_1 + i];
               }
            }
         }
         hr = SafeArrayUnaccessData(array_in_out->parray); //закрываем массив
         if (FAILED(hr)) return hr;
      }
   }
   else {
   hr = SafeArrayUnaccessData(array_in_out->parray); //закрываем массив
   if (FAILED(hr)) return hr;
   }

   return S_OK;
}

call        std::vector<str_index,std::allocator<str_index> >::vector<str_index,std::allocator<str_index> > (07FEBAD211C7h)  
         for (size_t i = 0; i < cElements_0; ++i) pairs2[i] = str_index{ i, pbstr[i*cElements_1 + offset] }; //сдвигаем на заданную размерность 
 mov         qword ptr [rbp+528h],0  
 jmp         CVBA::ArraySortS+1286h (07FEBADBC886h)  
 mov         rax,qword ptr [rbp+528h]  
 inc         rax  
 mov         qword ptr [rbp+528h],rax  
 movsxd      rax,dword ptr [cElements_0]  
 cmp         qword ptr [rbp+528h],rax  
 jae         CVBA::ArraySortS+12FEh (07FEBADBC8FEh)  
 mov         rax,qword ptr [rbp+528h]  
 mov         qword ptr [rbp+1858h],rax  
 movsxd      rax,dword ptr [cElements_1]  
 mov         rcx,qword ptr [rbp+528h]  
 imul        rcx,rax  
 mov         rax,rcx  
 movsxd      rcx,dword ptr [rbp+4C4h]  
 add         rax,rcx  
 mov         rcx,qword ptr [pbstr]  
 mov         rax,qword ptr [rcx+rax*8]  
 mov         qword ptr [rbp+1860h],rax  
 mov         rdx,qword ptr [rbp+528h]  
 lea         rcx,[rbp+4E8h]  
 call        std::vector<str_index,std::allocator<str_index> >::operator[] (07FEBAD2419Ch)  
 lea         rcx,[rbp+1858h]  
 mov         rdi,rax  
 mov         rsi,rcx  
 mov         ecx,10h  
 rep movs    byte ptr [rdi],byte ptr [rsi]  
 jmp         CVBA::ArraySortS+1275h (07FEBADBC875h)  
         if (!sort_order) {
 movsx       eax,word ptr [sort_order]  
 test        eax,eax  
 jne         CVBA::ArraySortS+1362h (07FEBADBC962h)  
            concurrency::parallel_buffered_sort(pairs2.begin(), pairs2.end());
 lea         rdx,[rbp+1888h]  
 lea         rcx,[rbp+4E8h]  
 call        std::vector<str_index,std::allocator<str_index> >::end (07FEBAD222F2h)  
 mov         qword ptr [rbp+2198h],rax  
 lea         rdx,[rbp+18B8h]  
 lea         rcx,[rbp+4E8h]  
 call        std::vector<str_index,std::allocator<str_index> >::begin (07FEBAD25691h)  
 mov         rcx,qword ptr [rbp+2198h]  
 mov         rdx,rcx  
 mov         rcx,rax  
 call        Concurrency::parallel_buffered_sort<std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > > > (07FEBAD24200h)  
 lea         rcx,[rbp+18B8h]  
 call        std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > >::~_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > > (07FEBAD25A01h)  
 lea         rcx,[rbp+1888h]  
 call        std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > >::~_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > > (07FEBAD25A01h)  
         }
         else {
 jmp         CVBA::ArraySortS+13D9h (07FEBADBC9D9h)  
            concurrency::parallel_buffered_sort(pairs2.begin(), pairs2.end(),
 lea         rax,[rbp+18E4h]  
 mov         rdi,rax  
 xor         eax,eax  
 mov         ecx,1  
 rep stos    byte ptr [rdi]  
 lea         rdx,[rbp+1908h]  
 lea         rcx,[rbp+4E8h]  
 call        std::vector<str_index,std::allocator<str_index> >::end (07FEBAD222F2h)  
 mov         qword ptr [rbp+2198h],rax  
 lea         rdx,[rbp+1938h]  
 lea         rcx,[rbp+4E8h]  
 call        std::vector<str_index,std::allocator<str_index> >::begin (07FEBAD25691h)  
 mov         r9d,800h  
 lea         r8,[rbp+18E4h]  
 mov         rcx,qword ptr [rbp+2198h]  
 mov         rdx,rcx  
 mov         rcx,rax  
 call        Concurrency::parallel_buffered_sort<std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > >,<lambda_f8ab91aa7f4cf484b4612b046fb09b61> > (07FEBAD9AAC0h)  
 lea         rcx,[rbp+1938h]  
 call        std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > >::~_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > > (07FEBAD25A01h)  
 lea         rcx,[rbp+1908h]  
 call        std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > >::~_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > > (07FEBAD25A01h)  
               [](str_index & l, str_index & r)
            {return l > r; });
         }
         std::vector<long> out2(pairs2.size());
 mov         edx,20h  
 lea         rcx,[rbp+548h]  
 call        std::vector<long,std::allocator<long> >::__autoclassinit2 (07FEBAD26528h)  
 lea         rcx,[rbp+1964h]  
 call        std::allocator<long>::allocator<long> (07FEBAD22BA8h)  
 mov         qword ptr [rbp+2198h],rax  
 lea         rcx,[rbp+4E8h]  
 call        std::vector<str_index,std::allocator<str_index> >::size (07FEBAD26C85h)  
 mov         rcx,qword ptr [rbp+2198h]  
 mov         r8,rcx  
 mov         rdx,rax  
 lea         rcx,[rbp+548h]  
 call        std::vector<long,std::allocator<long> >::vector<long,std::allocator<long> > (07FEBAD21163h)  
         std::transform(pairs2.begin(), pairs2.end(), out2.begin(), [](const str_index& i) { return i.index; });
 lea         rax,[rbp+1984h]  
 mov         rdi,rax  
 xor         eax,eax  
 mov         ecx,1  
 rep stos    byte ptr [rdi]  
 lea         rax,[rbp+19A8h]  
 mov         qword ptr [rbp+19D8h],rax  
 lea         rax,[rbp+19F8h]  
 mov         qword ptr [rbp+1A28h],rax  
 lea         rax,[rbp+1A48h]  
 mov         qword ptr [rbp+1A78h],rax  
 mov         rdx,qword ptr [rbp+19D8h]  
 lea         rcx,[rbp+548h]  
 call        std::vector<long,std::allocator<long> >::begin (07FEBAD2720Ch)  
 mov         qword ptr [rbp+2198h],rax  
 mov         rdx,qword ptr [rbp+1A28h]  
 lea         rcx,[rbp+4E8h]  
 call        std::vector<str_index,std::allocator<str_index> >::end (07FEBAD222F2h)  
 mov         qword ptr [rbp+21A0h],rax  
 mov         rdx,qword ptr [rbp+1A78h]  
 lea         rcx,[rbp+4E8h]  
 call        std::vector<str_index,std::allocator<str_index> >::begin (07FEBAD25691h)  
 movzx       ecx,byte ptr [rbp+1984h]  
 mov         byte ptr [rsp+20h],cl  
 mov         rcx,qword ptr [rbp+2198h]  
 mov         r9,rcx  
 mov         rcx,qword ptr [rbp+21A0h]  
 mov         r8,rcx  
 mov         rdx,rax  
 lea         rcx,[rbp+1A98h]  
 call        std::transform<std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > >,std::_Vector_iterator<std::_Vector_val<std::_Simple_types<long> > >,<lambda_9fd536576e85f845a9ad8056719b3be5> > (07FEBADA1B10h)  
 lea         rcx,[rbp+1A98h]  
 call        std::_Vector_iterator<std::_Vector_val<std::_Simple_types<long> > >::~_Vector_iterator<std::_Vector_val<std::_Simple_types<long> > > (07FEBAD2138Eh)  
         if (out_array_index) { //выводим индексы
 movsx       eax,word ptr [out_array_index]  
 test        eax,eax  
 je          CVBA::ArraySortS+15FBh (07FEBADBCBFBh)  
            CComSafeArray <long> outArray2(out2.size(), lLbound_0);
 mov         edx,8  
 lea         rcx,[rbp+588h]  
 call        ATL::CComSafeArray<long,3>::__autoclassinit2 (07FEBAD237A6h)  
 lea         rcx,[rbp+548h]  
 call        std::vector<long,std::allocator<long> >::size (07FEBAD27252h)  
 mov         r8d,dword ptr [lLbound_0]  
 mov         edx,eax  
 lea         rcx,[rbp+588h]  
 call        ATL::CComSafeArray<long,3>::CComSafeArray<long,3> (07FEBAD24138h)  
            for (long i = 0; i < out2.size(); i++) outArray2[i + lLbound_0] = out2[i] + lLbound_0;
 mov         dword ptr [rbp+5A4h],0  
 jmp         CVBA::ArraySortS+1538h (07FEBADBCB38h)  
 mov         eax,dword ptr [rbp+5A4h]  
 inc         eax  
 mov         dword ptr [rbp+5A4h],eax  
 movsxd      rax,dword ptr [rbp+5A4h]  
 mov         qword ptr [rbp+2198h],rax  
 lea         rcx,[rbp+548h]  
 call        std::vector<long,std::allocator<long> >::size (07FEBAD27252h)  
 mov         rcx,qword ptr [rbp+2198h]  
 cmp         rcx,rax  
 jae         CVBA::ArraySortS+15A4h (07FEBADBCBA4h)  
 movsxd      rax,dword ptr [rbp+5A4h]  
 mov         rdx,rax  
 lea         rcx,[rbp+548h]  
 call        std::vector<long,std::allocator<long> >::operator[] (07FEBAD2869Dh)  
 mov         eax,dword ptr [rax]  
 add         eax,dword ptr [lLbound_0]  
 mov         dword ptr [rbp+2194h],eax  
 mov         ecx,dword ptr [lLbound_0]  
 mov         edx,dword ptr [rbp+5A4h]  
 add         edx,ecx  
 mov         ecx,edx  
 mov         edx,ecx  
 lea         rcx,[rbp+588h]  
 call        ATL::CComSafeArray<long,3>::operator[] (07FEBAD23391h)  
 mov         ecx,dword ptr [rbp+2194h]  
 mov         dword ptr [rax],ecx  
 jmp         CVBA::ArraySortS+152Ah (07FEBADBCB2Ah)  
            CComVariant varOut(outArray2);
 lea         rcx,[rbp+588h]  
 call        ATL::CComSafeArray<long,3>::operator tagSAFEARRAY * __ptr64 (07FEBAD297EBh)  
 mov         rdx,rax  
 lea         rcx,[rbp+5C8h]  
 call        ATL::CComVariant::CComVariant (07FEBAD22E73h)  
            varOut.Detach(index_array_out);
 mov         rdx,qword ptr [index_array_out]  
 lea         rcx,[rbp+5C8h]  
 call        ATL::CComVariant::Detach (07FEBAD285ADh)  
            outArray2.Destroy();
 lea         rcx,[rbp+588h]  
 call        ATL::CComSafeArray<long,3>::Destroy (07FEBAD218A2h)  
         }
 lea         rcx,[rbp+5C8h]  
 call        ATL::CComVariant::~CComVariant (07FEBAD258B2h)  
 lea         rcx,[rbp+588h]  
 call        ATL::CComSafeArray<long,3>::~CComSafeArray<long,3> (07FEBAD25A1Ah)  
         else { //сортируем двухмерный массив поодному из измерений (столбец - сортировка строк)
 jmp         CVBA::ArraySortS+1715h (07FEBADBCD15h)  
            long cElements_full2 = cElements_0 * cElements_1;
 mov         eax,dword ptr [cElements_0]  
 imul        eax,dword ptr [cElements_1]  
 mov         dword ptr [rbp+5F4h],eax  
            std::vector <BSTR> vBSTR(pbstr, pbstr + cElements_full2); //передаем в вектор
 mov         edx,20h  
 lea         rcx,[rbp+618h]  
 call        std::vector<wchar_t * __ptr64,std::allocator<wchar_t * __ptr64> >::__autoclassinit2 (07FEBAD23A1Ch)  
 lea         rcx,[rbp+1AC4h]  
 call        std::allocator<wchar_t * __ptr64>::allocator<wchar_t * __ptr64> (07FEBAD2318Eh)  
 movsxd      rcx,dword ptr [rbp+5F4h]  
 mov         rdx,qword ptr [pbstr]  
 lea         rcx,[rdx+rcx*8]  
 mov         r9,rax  
 mov         r8,rcx  
 mov         rdx,qword ptr [pbstr]  
 lea         rcx,[rbp+618h]  
 call        std::vector<wchar_t * __ptr64,std::allocator<wchar_t * __ptr64> >::vector<wchar_t * __ptr64,std::allocator<wchar_t * __ptr64> ><wchar_t * __ptr64 * __ptr64,void> (07FEBAD22CE8h)  
            for (long i = 0; i < cElements_1; i++) {
 mov         dword ptr [rbp+654h],0  
 jmp         CVBA::ArraySortS+166Dh (07FEBADBCC6Dh)  
 mov         eax,dword ptr [rbp+654h]  
 inc         eax  
 mov         dword ptr [rbp+654h],eax  
 mov         eax,dword ptr [cElements_1]  
 cmp         dword ptr [rbp+654h],eax  
 jge         CVBA::ArraySortS+1709h (07FEBADBCD09h)  
               for (long j = 0; j < cElements_0; j++) {
 mov         dword ptr [rbp+674h],0  
 jmp         CVBA::ArraySortS+1699h (07FEBADBCC99h)  
 mov         eax,dword ptr [rbp+674h]  
 inc         eax  
 mov         dword ptr [rbp+674h],eax  
 mov         eax,dword ptr [cElements_0]  
 cmp         dword ptr [rbp+674h],eax  
 jge         CVBA::ArraySortS+1704h (07FEBADBCD04h)  
                  pbstr[i + j * cElements_1] = vBSTR[out2[j] * cElements_1 + i];
 movsxd      rax,dword ptr [rbp+674h]  
                  pbstr[i + j * cElements_1] = vBSTR[out2[j] * cElements_1 + i];
 mov         rdx,rax  
 lea         rcx,[rbp+548h]  
 call        std::vector<long,std::allocator<long> >::operator[] (07FEBAD2869Dh)  
 mov         eax,dword ptr [rax]  
 imul        eax,dword ptr [cElements_1]  
 add         eax,dword ptr [rbp+654h]  
 cdqe  
 mov         rdx,rax  
 lea         rcx,[rbp+618h]  
 call        std::vector<wchar_t * __ptr64,std::allocator<wchar_t * __ptr64> >::operator[] (07FEBAD254A7h)  
 mov         ecx,dword ptr [rbp+674h]  
 imul        ecx,dword ptr [cElements_1]  
 mov         edx,dword ptr [rbp+654h]  
 add         edx,ecx  
 mov         ecx,edx  
 movsxd      rcx,ecx  
 mov         rdx,qword ptr [pbstr]  
 mov         rax,qword ptr [rax]  
 mov         qword ptr [rdx+rcx*8],rax  
               }
 jmp         CVBA::ArraySortS+168Bh (07FEBADBCC8Bh)  
            }
 jmp         CVBA::ArraySortS+165Fh (07FEBADBCC5Fh)  
         }
 lea         rcx,[rbp+618h]  
 call        std::vector<wchar_t * __ptr64,std::allocator<wchar_t * __ptr64> >::~vector<wchar_t * __ptr64,std::allocator<wchar_t * __ptr64> > (07FEBAD2596Bh)  
         hr = SafeArrayUnaccessData(array_in_out->parray); //закрываем массив
 mov         rax,qword ptr [array_in_out]  
 mov         rcx,qword ptr [rax+8]  
 call        qword ptr [__imp_SafeArrayUnaccessData (07FEBB0AF698h)]  
 mov         dword ptr [hr],eax  
         if (FAILED(hr)) return hr;
 cmp         dword ptr [hr],0  
 jge         CVBA::ArraySortS+1764h (07FEBADBCD64h)  
 mov         eax,dword ptr [hr]  
 mov         dword ptr [rbp+1AE4h],eax  
 lea         rcx,[rbp+548h]  
 call        std::vector<long,std::allocator<long> >::~vector<long,std::allocator<long> > (07FEBAD22036h)  
 lea         rcx,[rbp+4E8h]  
 call        std::vector<str_index,std::allocator<str_index> >::~vector<str_index,std::allocator<str_index> > (07FEBAD22716h)  
 mov         eax,dword ptr [rbp+1AE4h]  
 jmp         CVBA::ArraySortS+24FBh (07FEBADBDAFBh)  
      }
 lea         rcx,[rbp+548h]  
 call        std::vector<long,std::allocator<long> >::~vector<long,std::allocator<long> > (07FEBAD22036h)  
 lea         rcx,[rbp+4E8h]  
 call        std::vector<str_index,std::allocator<str_index> >::~vector<str_index,std::allocator<str_index> > (07FEBAD22716h)  
         
   }
 jmp         CVBA::ArraySortS+24F9h (07FEBADBDAF9h)  
   ///////////////////////////////////////////////////////////////////////////////////////////////
   else if ((key_2 > -1 || key_3 > -1)) { //если больше условий 
 cmp         dword ptr [key_2],0FFFFFFFFh  
 jg          CVBA::ArraySortS+1797h (07FEBADBCD97h)  
 cmp         dword ptr [key_3],0FFFFFFFFh  
 jle         CVBA::ArraySortS+24D1h (07FEBADBDAD1h)  
      if (sort_orientation == 0) { //если сортировка по строкам
 cmp         dword ptr [sort_orientation],0  
 jne         CVBA::ArraySortS+1E35h (07FEBADBD435h)  
         //if (key_1 == -1) key_1 = lLbound_0;
         long offset1 = (key_1 - 1)*cElements_1; //сдвигаем на заданную размерность 
 mov         eax,dword ptr [key_1]  
 dec         eax  
 imul        eax,dword ptr [cElements_1]  
 mov         dword ptr [rbp+694h],eax  
         long offset2 = (key_2 - 1)*cElements_1; //сдвигаем на заданную размерность 
 mov         eax,dword ptr [key_2]  
 dec         eax  
 imul        eax,dword ptr [cElements_1]  
 mov         dword ptr [rbp+6B4h],eax  
         long offset3 = (key_3 - 1)*cElements_1; //сдвигаем на заданную размерность 
 mov         eax,dword ptr [key_3]  
 dec         eax  
 imul        eax,dword ptr [cElements_1]  
 mov         dword ptr [rbp+6D4h],eax  

         std::vector<str_index> pairs2(cElements_1);
 mov         edx,20h  
 lea         rcx,[rbp+6F8h]  
 call        std::vector<str_index,std::allocator<str_index> >::__autoclassinit2 (07FEBAD227E8h)  
 lea         rcx,[rbp+1B04h]  
 call        std::allocator<str_index>::allocator<str_index> (07FEBAD27351h)  
 movsxd      rcx,dword ptr [cElements_1]  
 mov         r8,rax  
 mov         rdx,rcx  
 lea         rcx,[rbp+6F8h]  
 call        std::vector<str_index,std::allocator<str_index> >::vector<str_index,std::allocator<str_index> > (07FEBAD211C7h)  
         for (size_t i = 0; i < cElements_1; ++i) {
 mov         qword ptr [rbp+738h],0  
 jmp         CVBA::ArraySortS+1837h (07FEBADBCE37h)  
 mov         rax,qword ptr [rbp+738h]  
 inc         rax  
 mov         qword ptr [rbp+738h],rax  
 movsxd      rax,dword ptr [cElements_1]  
 cmp         qword ptr [rbp+738h],rax  
 jae         CVBA::ArraySortS+19B0h (07FEBADBCFB0h)  
            _bstr_t BSTRtmp(pbstr[i + offset1]);
 mov         edx,8  
 lea         rcx,[rbp+758h]  
 call        _bstr_t::__autoclassinit2 (07FEBAD2886Eh)  
 movsxd      rax,dword ptr [rbp+694h]  
 mov         rcx,qword ptr [rbp+738h]  
 add         rcx,rax  
 mov         rax,rcx  
 mov         rcx,qword ptr [pbstr]  
 mov         rdx,qword ptr [rcx+rax*8]  
 lea         rcx,[rbp+758h]  
 call        _bstr_t::_bstr_t (07FEBAD25209h)  
            BSTRtmp= BSTRtmp + _bstr_t(pbstr[i + offset2]);
 movsxd      rax,dword ptr [rbp+6B4h]  
 mov         rcx,qword ptr [rbp+738h]  
 add         rcx,rax  
 mov         rax,rcx  
 mov         rcx,qword ptr [pbstr]  
 mov         rdx,qword ptr [rcx+rax*8]  
 lea         rcx,[rbp+1B28h]  
 call        _bstr_t::_bstr_t (07FEBAD25209h)  
 mov         r8,rax  
 lea         rdx,[rbp+1B48h]  
 lea         rcx,[rbp+758h]  
 call        _bstr_t::operator+ (07FEBAD263C0h)  
 mov         rdx,rax  
 lea         rcx,[rbp+758h]  
 call        _bstr_t::operator= (07FEBAD2A1C3h)  
 lea         rcx,[rbp+1B48h]  
 call        _bstr_t::~_bstr_t (07FEBAD25899h)  
 lea         rcx,[rbp+1B28h]  
 call        _bstr_t::~_bstr_t (07FEBAD25899h)  
            BSTRtmp = BSTRtmp + _bstr_t(pbstr[i + offset3]);
 movsxd      rax,dword ptr [rbp+6D4h]  
 mov         rcx,qword ptr [rbp+738h]  
 add         rcx,rax  
 mov         rax,rcx  
 mov         rcx,qword ptr [pbstr]  
 mov         rdx,qword ptr [rcx+rax*8]  
 lea         rcx,[rbp+1B68h]  
 call        _bstr_t::_bstr_t (07FEBAD25209h)  
 mov         r8,rax  
 lea         rdx,[rbp+1B88h]  
 lea         rcx,[rbp+758h]  
 call        _bstr_t::operator+ (07FEBAD263C0h)  
 mov         rdx,rax  
 lea         rcx,[rbp+758h]  
 call        _bstr_t::operator= (07FEBAD2A1C3h)  
 lea         rcx,[rbp+1B88h]  
 call        _bstr_t::~_bstr_t (07FEBAD25899h)  
 lea         rcx,[rbp+1B68h]  
 call        _bstr_t::~_bstr_t (07FEBAD25899h)  
            pairs2[i] = str_index{ i, BSTRtmp};
 mov         rax,qword ptr [rbp+738h]  
 mov         qword ptr [rbp+1BA8h],rax  
 lea         rcx,[rbp+758h]  
 call        _bstr_t::operator wchar_t * __ptr64 (07FEBAD24A39h)  
 mov         qword ptr [rbp+1BB0h],rax  
 mov         rdx,qword ptr [rbp+738h]  
 lea         rcx,[rbp+6F8h]  
 call        std::vector<str_index,std::allocator<str_index> >::operator[] (07FEBAD2419Ch)  
 lea         rcx,[rbp+1BA8h]  
 mov         rdi,rax  
 mov         rsi,rcx  
 mov         ecx,10h  
 rep movs    byte ptr [rdi],byte ptr [rsi]  
         }
 lea         rcx,[rbp+758h]  
 call        _bstr_t::~_bstr_t (07FEBAD25899h)  
 jmp         CVBA::ArraySortS+1826h (07FEBADBCE26h)  
         if (!sort_order) {
 movsx       eax,word ptr [sort_order]  
 test        eax,eax  
 jne         CVBA::ArraySortS+1A14h (07FEBADBD014h)  
            concurrency::parallel_buffered_sort(pairs2.begin(), pairs2.end());
 lea         rdx,[rbp+1BD8h]  
 lea         rcx,[rbp+6F8h]  
 call        std::vector<str_index,std::allocator<str_index> >::end (07FEBAD222F2h)  
 mov         qword ptr [rbp+2198h],rax  
 lea         rdx,[rbp+1C08h]  
 lea         rcx,[rbp+6F8h]  
 call        std::vector<str_index,std::allocator<str_index> >::begin (07FEBAD25691h)  
 mov         rcx,qword ptr [rbp+2198h]  
 mov         rdx,rcx  
 mov         rcx,rax  
 call        Concurrency::parallel_buffered_sort<std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > > > (07FEBAD24200h)  
 lea         rcx,[rbp+1C08h]  
 call        std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > >::~_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > > (07FEBAD25A01h)  
 lea         rcx,[rbp+1BD8h]  
 call        std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > >::~_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > > (07FEBAD25A01h)  
         }
         else {
 jmp         CVBA::ArraySortS+1A8Bh (07FEBADBD08Bh)  
            concurrency::parallel_buffered_sort(pairs2.begin(), pairs2.end(),
 lea         rax,[rbp+1C34h]  
 mov         rdi,rax  
 xor         eax,eax  
 mov         ecx,1  
 rep stos    byte ptr [rdi]  
 lea         rdx,[rbp+1C58h]  
 lea         rcx,[rbp+6F8h]  
 call        std::vector<str_index,std::allocator<str_index> >::end (07FEBAD222F2h)  
 mov         qword ptr [rbp+2198h],rax  
 lea         rdx,[rbp+1C88h]  
 lea         rcx,[rbp+6F8h]  
 call        std::vector<str_index,std::allocator<str_index> >::begin (07FEBAD25691h)  
 mov         r9d,800h  
 lea         r8,[rbp+1C34h]  
 mov         rcx,qword ptr [rbp+2198h]  
 mov         rdx,rcx  
 mov         rcx,rax  
 call        Concurrency::parallel_buffered_sort<std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > >,<lambda_260185c02fa9fe964833ea0560efad45> > (07FEBAD9A880h)  
 lea         rcx,[rbp+1C88h]  
 call        std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > >::~_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > > (07FEBAD25A01h)  
 lea         rcx,[rbp+1C58h]  
 call        std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > >::~_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > > (07FEBAD25A01h)  
               [](str_index & l, str_index & r)
            {return l > r; });
         }
         std::vector<long> out2(pairs2.size());
 mov         edx,20h  
 lea         rcx,[rbp+778h]  
 call        std::vector<long,std::allocator<long> >::__autoclassinit2 (07FEBAD26528h)  
 lea         rcx,[rbp+1CB4h]  
 call        std::allocator<long>::allocator<long> (07FEBAD22BA8h)  
 mov         qword ptr [rbp+2198h],rax  
 lea         rcx,[rbp+6F8h]  
 call        std::vector<str_index,std::allocator<str_index> >::size (07FEBAD26C85h)  
 mov         rcx,qword ptr [rbp+2198h]  
 mov         r8,rcx  
 mov         rdx,rax  
 lea         rcx,[rbp+778h]  
 call        std::vector<long,std::allocator<long> >::vector<long,std::allocator<long> > (07FEBAD21163h)  
         std::transform(pairs2.begin(), pairs2.end(), out2.begin(), [](const str_index& i) { return i.index; });
 lea         rax,[rbp+1CD4h]  
 mov         rdi,rax  
 xor         eax,eax  
 mov         ecx,1  
 rep stos    byte ptr [rdi]  
 lea         rax,[rbp+1CF8h]  
 mov         qword ptr [rbp+1D28h],rax  
 lea         rax,[rbp+1D48h]  
 mov         qword ptr [rbp+1D78h],rax  
 lea         rax,[rbp+1D98h]  
 mov         qword ptr [rbp+1DC8h],rax  
 mov         rdx,qword ptr [rbp+1D28h]  
 lea         rcx,[rbp+778h]  
 call        std::vector<long,std::allocator<long> >::begin (07FEBAD2720Ch)  
 mov         qword ptr [rbp+2198h],rax  
 mov         rdx,qword ptr [rbp+1D78h]  
 lea         rcx,[rbp+6F8h]  
 call        std::vector<str_index,std::allocator<str_index> >::end (07FEBAD222F2h)  
 mov         qword ptr [rbp+21A0h],rax  
 mov         rdx,qword ptr [rbp+1DC8h]  
 lea         rcx,[rbp+6F8h]  
 call        std::vector<str_index,std::allocator<str_index> >::begin (07FEBAD25691h)  
 movzx       ecx,byte ptr [rbp+1CD4h]  
 mov         byte ptr [rsp+20h],cl  
 mov         rcx,qword ptr [rbp+2198h]  
 mov         r9,rcx  
 mov         rcx,qword ptr [rbp+21A0h]  
 mov         r8,rcx  
 mov         rdx,rax  
 lea         rcx,[rbp+1DE8h]  
 call        std::transform<std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > >,std::_Vector_iterator<std::_Vector_val<std::_Simple_types<long> > >,<lambda_776edc1d02b9357403a7d40a27ef7d9a> > (07FEBADA1540h)  
 lea         rcx,[rbp+1DE8h]  
 call        std::_Vector_iterator<std::_Vector_val<std::_Simple_types<long> > >::~_Vector_iterator<std::_Vector_val<std::_Simple_types<long> > > (07FEBAD2138Eh)  
         if (out_array_index) { //выводим индексы
 movsx       eax,word ptr [out_array_index]  
 test        eax,eax  
 je          CVBA::ArraySortS+1CADh (07FEBADBD2ADh)  
            CComSafeArray <long> outArray2(out2.size(), lLbound_1);
 mov         edx,8  
 lea         rcx,[rbp+7B8h]  
 call        ATL::CComSafeArray<long,3>::__autoclassinit2 (07FEBAD237A6h)  
 lea         rcx,[rbp+778h]  
 call        std::vector<long,std::allocator<long> >::size (07FEBAD27252h)  
 mov         r8d,dword ptr [lLbound_1]  
 mov         edx,eax  
 lea         rcx,[rbp+7B8h]  
 call        ATL::CComSafeArray<long,3>::CComSafeArray<long,3> (07FEBAD24138h)  
            for (long i = 0; i < out2.size(); i++) outArray2[i + lLbound_1] = out2[i] + lLbound_1;
 mov         dword ptr [rbp+7D4h],0  
            for (long i = 0; i < out2.size(); i++) outArray2[i + lLbound_1] = out2[i] + lLbound_1;
 jmp         CVBA::ArraySortS+1BEAh (07FEBADBD1EAh)  
 mov         eax,dword ptr [rbp+7D4h]  
 inc         eax  
 mov         dword ptr [rbp+7D4h],eax  
 movsxd      rax,dword ptr [rbp+7D4h]  
 mov         qword ptr [rbp+2198h],rax  
 lea         rcx,[rbp+778h]  
 call        std::vector<long,std::allocator<long> >::size (07FEBAD27252h)  
 mov         rcx,qword ptr [rbp+2198h]  
 cmp         rcx,rax  
 jae         CVBA::ArraySortS+1C56h (07FEBADBD256h)  
 movsxd      rax,dword ptr [rbp+7D4h]  
 mov         rdx,rax  
 lea         rcx,[rbp+778h]  
 call        std::vector<long,std::allocator<long> >::operator[] (07FEBAD2869Dh)  
 mov         eax,dword ptr [rax]  
 add         eax,dword ptr [lLbound_1]  
 mov         dword ptr [rbp+2194h],eax  
 mov         ecx,dword ptr [lLbound_1]  
 mov         edx,dword ptr [rbp+7D4h]  
 add         edx,ecx  
 mov         ecx,edx  
 mov         edx,ecx  
 lea         rcx,[rbp+7B8h]  
 call        ATL::CComSafeArray<long,3>::operator[] (07FEBAD23391h)  
 mov         ecx,dword ptr [rbp+2194h]  
 mov         dword ptr [rax],ecx  
 jmp         CVBA::ArraySortS+1BDCh (07FEBADBD1DCh)  
            CComVariant varOut(outArray2);
 lea         rcx,[rbp+7B8h]  
 call        ATL::CComSafeArray<long,3>::operator tagSAFEARRAY * __ptr64 (07FEBAD297EBh)  
 mov         rdx,rax  
 lea         rcx,[rbp+7F8h]  
 call        ATL::CComVariant::CComVariant (07FEBAD22E73h)  
            varOut.Detach(index_array_out);
 mov         rdx,qword ptr [index_array_out]  
 lea         rcx,[rbp+7F8h]  
 call        ATL::CComVariant::Detach (07FEBAD285ADh)  
            outArray2.Destroy();
 lea         rcx,[rbp+7B8h]  
 call        ATL::CComSafeArray<long,3>::Destroy (07FEBAD218A2h)  
         }
 lea         rcx,[rbp+7F8h]  
 call        ATL::CComVariant::~CComVariant (07FEBAD258B2h)  
 lea         rcx,[rbp+7B8h]  
 call        ATL::CComSafeArray<long,3>::~CComSafeArray<long,3> (07FEBAD25A1Ah)  
         else { //сортируем двухмерный массив поодному из измерений (столбец - сортировка строк)
 jmp         CVBA::ArraySortS+1DC9h (07FEBADBD3C9h)  
            long cElements_full2 = cElements_0 * cElements_1;
 mov         eax,dword ptr [cElements_0]  
 imul        eax,dword ptr [cElements_1]  
 mov         dword ptr [rbp+824h],eax  
            std::vector <BSTR> vBSTR(pbstr, pbstr + cElements_full2); //передаем в вектор
 mov         edx,20h  
 lea         rcx,[rbp+848h]  
 call        std::vector<wchar_t * __ptr64,std::allocator<wchar_t * __ptr64> >::__autoclassinit2 (07FEBAD23A1Ch)  
 lea         rcx,[rbp+1E14h]  
 call        std::allocator<wchar_t * __ptr64>::allocator<wchar_t * __ptr64> (07FEBAD2318Eh)  
 movsxd      rcx,dword ptr [rbp+824h]  
 mov         rdx,qword ptr [pbstr]  
 lea         rcx,[rdx+rcx*8]  
 mov         r9,rax  
 mov         r8,rcx  
 mov         rdx,qword ptr [pbstr]  
 lea         rcx,[rbp+848h]  
 call        std::vector<wchar_t * __ptr64,std::allocator<wchar_t * __ptr64> >::vector<wchar_t * __ptr64,std::allocator<wchar_t * __ptr64> ><wchar_t * __ptr64 * __ptr64,void> (07FEBAD22CE8h)  
            for (long i = 0; i < cElements_0; i++) {
 mov         dword ptr [rbp+884h],0  
 jmp         CVBA::ArraySortS+1D1Fh (07FEBADBD31Fh)  
 mov         eax,dword ptr [rbp+884h]  
 inc         eax  
 mov         dword ptr [rbp+884h],eax  
 mov         eax,dword ptr [cElements_0]  
 cmp         dword ptr [rbp+884h],eax  
 jge         CVBA::ArraySortS+1DBDh (07FEBADBD3BDh)  
               for (long j = 0; j < cElements_1; j++) {
 mov         dword ptr [rbp+8A4h],0  
 jmp         CVBA::ArraySortS+1D48h (07FEBADBD348h)  
 mov         eax,dword ptr [rbp+8A4h]  
 inc         eax  
 mov         dword ptr [rbp+8A4h],eax  
 mov         eax,dword ptr [cElements_1]  
 cmp         dword ptr [rbp+8A4h],eax  
 jge         CVBA::ArraySortS+1DB8h (07FEBADBD3B8h)  
                  pbstr[j + i * cElements_1] = vBSTR[out2[j] + i * cElements_1];
 movsxd      rax,dword ptr [rbp+8A4h]  
 mov         rdx,rax  
 lea         rcx,[rbp+778h]  
 call        std::vector<long,std::allocator<long> >::operator[] (07FEBAD2869Dh)  
 mov         ecx,dword ptr [rbp+884h]  
 imul        ecx,dword ptr [cElements_1]  
 mov         eax,dword ptr [rax]  
 add         eax,ecx  
 cdqe  
 mov         rdx,rax  
 lea         rcx,[rbp+848h]  
 call        std::vector<wchar_t * __ptr64,std::allocator<wchar_t * __ptr64> >::operator[] (07FEBAD254A7h)  
 mov         ecx,dword ptr [rbp+884h]  
 imul        ecx,dword ptr [cElements_1]  
 mov         edx,dword ptr [rbp+8A4h]  
 add         edx,ecx  
 mov         ecx,edx  
 movsxd      rcx,ecx  
 mov         rdx,qword ptr [pbstr]  
 mov         rax,qword ptr [rax]  
 mov         qword ptr [rdx+rcx*8],rax  
               }
 jmp         CVBA::ArraySortS+1D3Ah (07FEBADBD33Ah)  
            }
 jmp         CVBA::ArraySortS+1D11h (07FEBADBD311h)  
         }
 lea         rcx,[rbp+848h]  
 call        std::vector<wchar_t * __ptr64,std::allocator<wchar_t * __ptr64> >::~vector<wchar_t * __ptr64,std::allocator<wchar_t * __ptr64> > (07FEBAD2596Bh)  
         hr = SafeArrayUnaccessData(array_in_out->parray); //закрываем массив
 mov         rax,qword ptr [array_in_out]  
 mov         rcx,qword ptr [rax+8]  
 call        qword ptr [__imp_SafeArrayUnaccessData (07FEBB0AF698h)]  
 mov         dword ptr [hr],eax  
         if (FAILED(hr)) return hr;
 cmp         dword ptr [hr],0  
 jge         CVBA::ArraySortS+1E18h (07FEBADBD418h)  
 mov         eax,dword ptr [hr]  
 mov         dword ptr [rbp+1E34h],eax  
 lea         rcx,[rbp+778h]  
 call        std::vector<long,std::allocator<long> >::~vector<long,std::allocator<long> > (07FEBAD22036h)  
 lea         rcx,[rbp+6F8h]  
 call        std::vector<str_index,std::allocator<str_index> >::~vector<str_index,std::allocator<str_index> > (07FEBAD22716h)  
 mov         eax,dword ptr [rbp+1E34h]  
 jmp         CVBA::ArraySortS+24FBh (07FEBADBDAFBh)  
      }
 lea         rcx,[rbp+778h]  
 call        std::vector<long,std::allocator<long> >::~vector<long,std::allocator<long> > (07FEBAD22036h)  
 lea         rcx,[rbp+6F8h]  
 call        std::vector<str_index,std::allocator<str_index> >::~vector<str_index,std::allocator<str_index> > (07FEBAD22716h)  
 jmp         CVBA::ArraySortS+24CFh (07FEBADBDACFh)  
      else if (sort_orientation == 1) { //если сортировка по столбцам
 cmp         dword ptr [sort_orientation],1  
 jne         CVBA::ArraySortS+24CFh (07FEBADBDACFh)  
         //if (key_1 == -1) key_1 = lLbound_1;
         long offset1 = (key_1 - 1); //сдвигаем на заданную размерность 
 mov         eax,dword ptr [key_1]  
 dec         eax  
 mov         dword ptr [rbp+8C4h],eax  
         long offset2 = (key_2 - 1); //сдвигаем на заданную размерность 
 mov         eax,dword ptr [key_2]  
 dec         eax  
 mov         dword ptr [rbp+8E4h],eax  
         long offset3 = (key_3 - 1); //сдвигаем на заданную размерность 
 mov         eax,dword ptr [key_3]  
 dec         eax  
 mov         dword ptr [rbp+904h],eax  
         std::vector<str_index> pairs2(cElements_0);
 mov         edx,20h  
 lea         rcx,[rbp+928h]  
 call        std::vector<str_index,std::allocator<str_index> >::__autoclassinit2 (07FEBAD227E8h)  
 lea         rcx,[rbp+1E54h]  
 call        std::allocator<str_index>::allocator<str_index> (07FEBAD27351h)  
 movsxd      rcx,dword ptr [cElements_0]  
 mov         r8,rax  
 mov         rdx,rcx  
 lea         rcx,[rbp+928h]  
 call        std::vector<str_index,std::allocator<str_index> >::vector<str_index,std::allocator<str_index> > (07FEBAD211C7h)  
         for (size_t i = 0; i < cElements_0; ++i) {
 mov         qword ptr [rbp+968h],0  
 jmp         CVBA::ArraySortS+1EBDh (07FEBADBD4BDh)  
 mov         rax,qword ptr [rbp+968h]  
 inc         rax  
 mov         qword ptr [rbp+968h],rax  
 movsxd      rax,dword ptr [cElements_0]  
 cmp         qword ptr [rbp+968h],rax  
 jae         CVBA::ArraySortS+2054h (07FEBADBD654h)  
            _bstr_t BSTRtmp(pbstr[i*cElements_1 + offset1]);
 mov         edx,8  
 lea         rcx,[rbp+988h]  
 call        _bstr_t::__autoclassinit2 (07FEBAD2886Eh)  
 movsxd      rax,dword ptr [cElements_1]  
 mov         rcx,qword ptr [rbp+968h]  
 imul        rcx,rax  
 mov         rax,rcx  
 movsxd      rcx,dword ptr [rbp+8C4h]  
 add         rax,rcx  
 mov         rcx,qword ptr [pbstr]  
 mov         rdx,qword ptr [rcx+rax*8]  
 lea         rcx,[rbp+988h]  
 call        _bstr_t::_bstr_t (07FEBAD25209h)  
            BSTRtmp = BSTRtmp + _bstr_t(pbstr[i*cElements_1 + offset2]);
 movsxd      rax,dword ptr [cElements_1]  
            BSTRtmp = BSTRtmp + _bstr_t(pbstr[i*cElements_1 + offset2]);
 mov         rcx,qword ptr [rbp+968h]  
 imul        rcx,rax  
 mov         rax,rcx  
 movsxd      rcx,dword ptr [rbp+8E4h]  
 add         rax,rcx  
 mov         rcx,qword ptr [pbstr]  
 mov         rdx,qword ptr [rcx+rax*8]  
 lea         rcx,[rbp+1E78h]  
 call        _bstr_t::_bstr_t (07FEBAD25209h)  
 mov         r8,rax  
 lea         rdx,[rbp+1E98h]  
 lea         rcx,[rbp+988h]  
 call        _bstr_t::operator+ (07FEBAD263C0h)  
 mov         rdx,rax  
 lea         rcx,[rbp+988h]  
 call        _bstr_t::operator= (07FEBAD2A1C3h)  
 lea         rcx,[rbp+1E98h]  
 call        _bstr_t::~_bstr_t (07FEBAD25899h)  
 lea         rcx,[rbp+1E78h]  
 call        _bstr_t::~_bstr_t (07FEBAD25899h)  
            BSTRtmp = BSTRtmp + _bstr_t(pbstr[i*cElements_1 + offset3]);
 movsxd      rax,dword ptr [cElements_1]  
 mov         rcx,qword ptr [rbp+968h]  
 imul        rcx,rax  
 mov         rax,rcx  
 movsxd      rcx,dword ptr [rbp+904h]  
 add         rax,rcx  
 mov         rcx,qword ptr [pbstr]  
 mov         rdx,qword ptr [rcx+rax*8]  
 lea         rcx,[rbp+1EB8h]  
 call        _bstr_t::_bstr_t (07FEBAD25209h)  
 mov         r8,rax  
 lea         rdx,[rbp+1ED8h]  
 lea         rcx,[rbp+988h]  
 call        _bstr_t::operator+ (07FEBAD263C0h)  
 mov         rdx,rax  
 lea         rcx,[rbp+988h]  
 call        _bstr_t::operator= (07FEBAD2A1C3h)  
 lea         rcx,[rbp+1ED8h]  
 call        _bstr_t::~_bstr_t (07FEBAD25899h)  
 lea         rcx,[rbp+1EB8h]  
 call        _bstr_t::~_bstr_t (07FEBAD25899h)  
            pairs2[i] = str_index{ i, BSTRtmp };
 mov         rax,qword ptr [rbp+968h]  
 mov         qword ptr [rbp+1EF8h],rax  
 lea         rcx,[rbp+988h]  
 call        _bstr_t::operator wchar_t * __ptr64 (07FEBAD24A39h)  
 mov         qword ptr [rbp+1F00h],rax  
 mov         rdx,qword ptr [rbp+968h]  
 lea         rcx,[rbp+928h]  
 call        std::vector<str_index,std::allocator<str_index> >::operator[] (07FEBAD2419Ch)  
 lea         rcx,[rbp+1EF8h]  
 mov         rdi,rax  
 mov         rsi,rcx  
 mov         ecx,10h  
 rep movs    byte ptr [rdi],byte ptr [rsi]  
         }
 lea         rcx,[rbp+988h]  
 call        _bstr_t::~_bstr_t (07FEBAD25899h)  
 jmp         CVBA::ArraySortS+1EACh (07FEBADBD4ACh)  
         if (!sort_order) {
 movsx       eax,word ptr [sort_order]  
 test        eax,eax  
 jne         CVBA::ArraySortS+20B8h (07FEBADBD6B8h)  
            concurrency::parallel_buffered_sort(pairs2.begin(), pairs2.end());
 lea         rdx,[rbp+1F28h]  
 lea         rcx,[rbp+928h]  
 call        std::vector<str_index,std::allocator<str_index> >::end (07FEBAD222F2h)  
 mov         qword ptr [rbp+2198h],rax  
 lea         rdx,[rbp+1F58h]  
 lea         rcx,[rbp+928h]  
 call        std::vector<str_index,std::allocator<str_index> >::begin (07FEBAD25691h)  
 mov         rcx,qword ptr [rbp+2198h]  
 mov         rdx,rcx  
 mov         rcx,rax  
 call        Concurrency::parallel_buffered_sort<std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > > > (07FEBAD24200h)  
 lea         rcx,[rbp+1F58h]  
 call        std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > >::~_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > > (07FEBAD25A01h)  
 lea         rcx,[rbp+1F28h]  
 call        std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > >::~_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > > (07FEBAD25A01h)  
         }
         else {
 jmp         CVBA::ArraySortS+212Fh (07FEBADBD72Fh)  
            concurrency::parallel_buffered_sort(pairs2.begin(), pairs2.end(),
 lea         rax,[rbp+1F84h]  
 mov         rdi,rax  
 xor         eax,eax  
 mov         ecx,1  
 rep stos    byte ptr [rdi]  
 lea         rdx,[rbp+1FA8h]  
 lea         rcx,[rbp+928h]  
 call        std::vector<str_index,std::allocator<str_index> >::end (07FEBAD222F2h)  
 mov         qword ptr [rbp+2198h],rax  
 lea         rdx,[rbp+1FD8h]  
 lea         rcx,[rbp+928h]  
 call        std::vector<str_index,std::allocator<str_index> >::begin (07FEBAD25691h)  
 mov         r9d,800h  
 lea         r8,[rbp+1F84h]  
 mov         rcx,qword ptr [rbp+2198h]  
 mov         rdx,rcx  
 mov         rcx,rax  
 call        Concurrency::parallel_buffered_sort<std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > >,<lambda_55637c4cd46e34d3866fc6f89993b4ac> > (07FEBAD9A9A0h)  
 lea         rcx,[rbp+1FD8h]  
 call        std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > >::~_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > > (07FEBAD25A01h)  
 lea         rcx,[rbp+1FA8h]  
 call        std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > >::~_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > > (07FEBAD25A01h)  
               [](str_index & l, str_index & r)
            {return l > r; });
         }
         std::vector<long> out2(pairs2.size());
 mov         edx,20h  
 lea         rcx,[rbp+9A8h]  
 call        std::vector<long,std::allocator<long> >::__autoclassinit2 (07FEBAD26528h)  
 lea         rcx,[rbp+2004h]  
 call        std::allocator<long>::allocator<long> (07FEBAD22BA8h)  
 mov         qword ptr [rbp+2198h],rax  
 lea         rcx,[rbp+928h]  
 call        std::vector<str_index,std::allocator<str_index> >::size (07FEBAD26C85h)  
 mov         rcx,qword ptr [rbp+2198h]  
 mov         r8,rcx  
 mov         rdx,rax  
 lea         rcx,[rbp+9A8h]  
 call        std::vector<long,std::allocator<long> >::vector<long,std::allocator<long> > (07FEBAD21163h)  
         std::transform(pairs2.begin(), pairs2.end(), out2.begin(), [](const str_index& i) { return i.index; });
 lea         rax,[rbp+2024h]  
 mov         rdi,rax  
 xor         eax,eax  
 mov         ecx,1  
 rep stos    byte ptr [rdi]  
 lea         rax,[rbp+2048h]  
 mov         qword ptr [rbp+2078h],rax  
 lea         rax,[rbp+2098h]  
 mov         qword ptr [rbp+20C8h],rax  
 lea         rax,[rbp+20E8h]  
 mov         qword ptr [rbp+2118h],rax  
 mov         rdx,qword ptr [rbp+2078h]  
 lea         rcx,[rbp+9A8h]  
 call        std::vector<long,std::allocator<long> >::begin (07FEBAD2720Ch)  
 mov         qword ptr [rbp+2198h],rax  
 mov         rdx,qword ptr [rbp+20C8h]  
 lea         rcx,[rbp+928h]  
 call        std::vector<str_index,std::allocator<str_index> >::end (07FEBAD222F2h)  
 mov         qword ptr [rbp+21A0h],rax  
 mov         rdx,qword ptr [rbp+2118h]  
 lea         rcx,[rbp+928h]  
 call        std::vector<str_index,std::allocator<str_index> >::begin (07FEBAD25691h)  
 movzx       ecx,byte ptr [rbp+2024h]  
 mov         byte ptr [rsp+20h],cl  
 mov         rcx,qword ptr [rbp+2198h]  
 mov         r9,rcx  
 mov         rcx,qword ptr [rbp+21A0h]  
 mov         r8,rcx  
 mov         rdx,rax  
 lea         rcx,[rbp+2138h]  
 call        std::transform<std::_Vector_iterator<std::_Vector_val<std::_Simple_types<str_index> > >,std::_Vector_iterator<std::_Vector_val<std::_Simple_types<long> > >,<lambda_2557b4ae67d44c0340aa9fd897722f4b> > (07FEBADA1350h)  
 lea         rcx,[rbp+2138h]  
 call        std::_Vector_iterator<std::_Vector_val<std::_Simple_types<long> > >::~_Vector_iterator<std::_Vector_val<std::_Simple_types<long> > > (07FEBAD2138Eh)  
         if (out_array_index) { //выводим индексы
 movsx       eax,word ptr [out_array_index]  
 test        eax,eax  
 je          CVBA::ArraySortS+2351h (07FEBADBD951h)  
            CComSafeArray <long> outArray2(out2.size(), lLbound_0);
 mov         edx,8  
 lea         rcx,[rbp+9E8h]  
 call        ATL::CComSafeArray<long,3>::__autoclassinit2 (07FEBAD237A6h)  
 lea         rcx,[rbp+9A8h]  
 call        std::vector<long,std::allocator<long> >::size (07FEBAD27252h)  
 mov         r8d,dword ptr [lLbound_0]  
 mov         edx,eax  
 lea         rcx,[rbp+9E8h]  
 call        ATL::CComSafeArray<long,3>::CComSafeArray<long,3> (07FEBAD24138h)  
            for (long i = 0; i < out2.size(); i++) outArray2[i + lLbound_0] = out2[i] + lLbound_0;
 mov         dword ptr [rbp+0A04h],0  
 jmp         CVBA::ArraySortS+228Eh (07FEBADBD88Eh)  
 mov         eax,dword ptr [rbp+0A04h]  
 inc         eax  
 mov         dword ptr [rbp+0A04h],eax  
 movsxd      rax,dword ptr [rbp+0A04h]  
 mov         qword ptr [rbp+2198h],rax  
 lea         rcx,[rbp+9A8h]  
 call        std::vector<long,std::allocator<long> >::size (07FEBAD27252h)  
 mov         rcx,qword ptr [rbp+2198h]  
 cmp         rcx,rax  
 jae         CVBA::ArraySortS+22FAh (07FEBADBD8FAh)  
 movsxd      rax,dword ptr [rbp+0A04h]  
 mov         rdx,rax  
 lea         rcx,[rbp+9A8h]  
 call        std::vector<long,std::allocator<long> >::operator[] (07FEBAD2869Dh)  
 mov         eax,dword ptr [rax]  
 add         eax,dword ptr [lLbound_0]  
 mov         dword ptr [rbp+2194h],eax  
 mov         ecx,dword ptr [lLbound_0]  
 mov         edx,dword ptr [rbp+0A04h]  
 add         edx,ecx  
 mov         ecx,edx  
 mov         edx,ecx  
 lea         rcx,[rbp+9E8h]  
 call        ATL::CComSafeArray<long,3>::operator[] (07FEBAD23391h)  
 mov         ecx,dword ptr [rbp+2194h]  
 mov         dword ptr [rax],ecx  
 jmp         CVBA::ArraySortS+2280h (07FEBADBD880h)  
            CComVariant varOut(outArray2);
 lea         rcx,[rbp+9E8h]  
 call        ATL::CComSafeArray<long,3>::operator tagSAFEARRAY * __ptr64 (07FEBAD297EBh)  
 mov         rdx,rax  
 lea         rcx,[rbp+0A28h]  
 call        ATL::CComVariant::CComVariant (07FEBAD22E73h)  
            varOut.Detach(index_array_out);
 mov         rdx,qword ptr [index_array_out]  
 lea         rcx,[rbp+0A28h]  
 call        ATL::CComVariant::Detach (07FEBAD285ADh)  
            outArray2.Destroy();
 lea         rcx,[rbp+9E8h]  
 call        ATL::CComSafeArray<long,3>::Destroy (07FEBAD218A2h)  
         }
 lea         rcx,[rbp+0A28h]  
 call        ATL::CComVariant::~CComVariant (07FEBAD258B2h)  
 lea         rcx,[rbp+9E8h]  
 call        ATL::CComSafeArray<long,3>::~CComSafeArray<long,3> (07FEBAD25A1Ah)  
         else { //сортируем двухмерный массив по одному из измерений (столбец - сортировка строк)
 jmp         CVBA::ArraySortS+246Bh (07FEBADBDA6Bh)  
            long cElements_full2 = cElements_0 * cElements_1;
 mov         eax,dword ptr [cElements_0]  
 imul        eax,dword ptr [cElements_1]  
 mov         dword ptr [rbp+0A54h],eax  
            std::vector <BSTR> vBSTR(pbstr, pbstr + cElements_full2); //передаем в вектор
 mov         edx,20h  
 lea         rcx,[rbp+0A78h]  
 call        std::vector<wchar_t * __ptr64,std::allocator<wchar_t * __ptr64> >::__autoclassinit2 (07FEBAD23A1Ch)  
 lea         rcx,[rbp+2164h]  
 call        std::allocator<wchar_t * __ptr64>::allocator<wchar_t * __ptr64> (07FEBAD2318Eh)  
 movsxd      rcx,dword ptr [rbp+0A54h]  
 mov         rdx,qword ptr [pbstr]  
 lea         rcx,[rdx+rcx*8]  
 mov         r9,rax  
 mov         r8,rcx  
 mov         rdx,qword ptr [pbstr]  
 lea         rcx,[rbp+0A78h]  
 call        std::vector<wchar_t * __ptr64,std::allocator<wchar_t * __ptr64> >::vector<wchar_t * __ptr64,std::allocator<wchar_t * __ptr64> ><wchar_t * __ptr64 * __ptr64,void> (07FEBAD22CE8h)  
            for (long i = 0; i < cElements_1; i++) {
 mov         dword ptr [rbp+0AB4h],0  
 jmp         CVBA::ArraySortS+23C3h (07FEBADBD9C3h)  
 mov         eax,dword ptr [rbp+0AB4h]  
 inc         eax  
 mov         dword ptr [rbp+0AB4h],eax  
 mov         eax,dword ptr [cElements_1]  
 cmp         dword ptr [rbp+0AB4h],eax  
 jge         CVBA::ArraySortS+245Fh (07FEBADBDA5Fh)  
               for (long j = 0; j < cElements_0; j++) {
 mov         dword ptr [rbp+0AD4h],0  
 jmp         CVBA::ArraySortS+23EFh (07FEBADBD9EFh)  
 mov         eax,dword ptr [rbp+0AD4h]  
 inc         eax  
 mov         dword ptr [rbp+0AD4h],eax  
 mov         eax,dword ptr [cElements_0]  
 cmp         dword ptr [rbp+0AD4h],eax  
 jge         CVBA::ArraySortS+245Ah (07FEBADBDA5Ah)  
                  pbstr[i + j * cElements_1] = vBSTR[out2[j] * cElements_1 + i];
 movsxd      rax,dword ptr [rbp+0AD4h]  
 mov         rdx,rax  
 lea         rcx,[rbp+9A8h]  
 call        std::vector<long,std::allocator<long> >::operator[] (07FEBAD2869Dh)  
 mov         eax,dword ptr [rax]  
 imul        eax,dword ptr [cElements_1]  
 add         eax,dword ptr [rbp+0AB4h]  
 cdqe  
 mov         rdx,rax  
 lea         rcx,[rbp+0A78h]  
 call        std::vector<wchar_t * __ptr64,std::allocator<wchar_t * __ptr64> >::operator[] (07FEBAD254A7h)  
 mov         ecx,dword ptr [rbp+0AD4h]  
 imul        ecx,dword ptr [cElements_1]  
 mov         edx,dword ptr [rbp+0AB4h]  
 add         edx,ecx  
 mov         ecx,edx  
 movsxd      rcx,ecx  
 mov         rdx,qword ptr [pbstr]  
 mov         rax,qword ptr [rax]  
 mov         qword ptr [rdx+rcx*8],rax  
               }
 jmp         CVBA::ArraySortS+23E1h (07FEBADBD9E1h)  
            }
 jmp         CVBA::ArraySortS+23B5h (07FEBADBD9B5h)  
         }
 lea         rcx,[rbp+0A78h]  
 call        std::vector<wchar_t * __ptr64,std::allocator<wchar_t * __ptr64> >::~vector<wchar_t * __ptr64,std::allocator<wchar_t * __ptr64> > (07FEBAD2596Bh)  
         hr = SafeArrayUnaccessData(array_in_out->parray); //закрываем массив
 mov         rax,qword ptr [array_in_out]  
 mov         rcx,qword ptr [rax+8]  
 call        qword ptr [__imp_SafeArrayUnaccessData (07FEBB0AF698h)]  
 mov         dword ptr [hr],eax  
         if (FAILED(hr)) return hr;
 cmp         dword ptr [hr],0  
 jge         CVBA::ArraySortS+24B7h (07FEBADBDAB7h)  
 mov         eax,dword ptr [hr]  
 mov         dword ptr [rbp+2184h],eax  
 lea         rcx,[rbp+9A8h]  
 call        std::vector<long,std::allocator<long> >::~vector<long,std::allocator<long> > (07FEBAD22036h)  
 lea         rcx,[rbp+928h]  
 call        std::vector<str_index,std::allocator<str_index> >::~vector<str_index,std::allocator<str_index> > (07FEBAD22716h)  
 mov         eax,dword ptr [rbp+2184h]  
 jmp         CVBA::ArraySortS+24FBh (07FEBADBDAFBh)  
      }
 lea         rcx,[rbp+9A8h]  
 call        std::vector<long,std::allocator<long> >::~vector<long,std::allocator<long> > (07FEBAD22036h)  
 lea         rcx,[rbp+928h]  
 call        std::vector<str_index,std::allocator<str_index> >::~vector<str_index,std::allocator<str_index> > (07FEBAD22716h)  
   }
   else {
 jmp         CVBA::ArraySortS+24F9h (07FEBADBDAF9h)  
   hr = SafeArrayUnaccessData(array_in_out->parray); //закрываем массив
 mov         rax,qword ptr [array_in_out]  
 mov         rcx,qword ptr [rax+8]  
 call        qword ptr [__imp_SafeArrayUnaccessData (07FEBB0AF698h)]  
 mov         dword ptr [hr],eax  
   if (FAILED(hr)) return hr;
 cmp         dword ptr [hr],0  
 jge         CVBA::ArraySortS+24F9h (07FEBADBDAF9h)  
 mov         eax,dword ptr [hr]  
 jmp         CVBA::ArraySortS+24FBh (07FEBADBDAFBh)  
   }

   return S_OK;
 xor         eax,eax  
}