extern "C" __declspec(dllexport) LPXLOPER12  WINAPI FindRowsInCSVansi(wchar_t *  file, char* findStr, bool multiLine, int fileFlagNoBuffering)
{
    LPXLOPER12 OperOut = TempErr12(xlerrValue);
       
    const DWORD  nNumberOfBytesToRead = 16777216;//67108864;//33554432; //16777216;//8388608;//читаем в буфер байты
    size_t findStrLen = strlen(findStr);
    if (findStrLen >= nNumberOfBytesToRead) { return OperOut; };
 
    // создаем события с автоматическим сбросом
    HANDLE hEndRead = CreateEvent(NULL, FALSE, FALSE, NULL);// дескриптор события
    if (hEndRead == NULL){  return OperOut; }
 
    // открываем файл для чтения
    HANDLE hFile = CreateFile(  // дескриптор файла
        file,   // имя файла
        GENERIC_READ,          // чтение из файла
        FILE_SHARE_READ,       // совместный доступ к файлу
        NULL,                  // защиты нет
        OPEN_EXISTING,         // открываем существующий файл
        FILE_FLAG_OVERLAPPED | (fileFlagNoBuffering != 0 ? FILE_FLAG_NO_BUFFERING : FILE_FLAG_RANDOM_ACCESS),// асинхронный ввод//отключаем системный буфер
        NULL                   // шаблона нет
    );
    // проверяем на успешное открытие
    if (hFile == INVALID_HANDLE_VALUE)
    {
        CloseHandle(hEndRead);
        return OperOut;
    }
 
    char* notAlignBuf = new char[nNumberOfBytesToRead * 2 + 4096 + 1]; //буфер
    char* buf = notAlignBuf + nNumberOfBytesToRead;; //буфер
    if (size_t(buf) % 4096) { buf += 4096 - (size_t(buf) % 4096); }//адрес принимающего буфера тоже должен быть выровнен по размеру сектора/страницы 
 
    char* notAlignBufWork = new char[nNumberOfBytesToRead * 2 + 4096 + 1]; //буфер Рабочий
    char* bufWork = notAlignBufWork + nNumberOfBytesToRead; //буфер
    if (size_t(bufWork) % 4096) { bufWork += 4096 - (size_t(bufWork) % 4096); }//адрес рабочего буфера тоже выровнял по размеру сектора/страницы  
 
    buf[nNumberOfBytesToRead] = '\0';//добавим нуль-терминатор
    bufWork[0] = '\0';//добавим нуль-терминатор
    bufWork[nNumberOfBytesToRead] = '\0';//добавим нуль-терминатор
 
    DWORD dwBytesReadWork = 0;
    DWORD findStatus = 0; //статус поиска
    bool errHandleEOF = false; //метка конца файла
    char* find;// указатель для поиска
    char* strStart;
    char* strEnd;
    char* bufWorkNew = bufWork;//буфер с учетом полной строки
    size_t strStartLen = 0;
    size_t strCount = 1; //счетчик строк
    std::string strOut; //итоговая строка
 
    _ULARGE_INTEGER ui; //Представляет 64-разрядное целое число без знака обединяя два 32-х разрядных
    ui.QuadPart = 0;
 
    OVERLAPPED  ovl;   // структура управления асинхронным доступом к файлу// инициализируем структуру OVERLAPPED
    ovl.Offset = 0;         // младшая часть смещения равна 0
    ovl.OffsetHigh = 0;      // старшая часть смещения равна 0
    ovl.hEvent = hEndRead;   // событие для оповещения завершения чтения
 
    // читаем данные из файла
    for (;;)
    {
        DWORD  dwBytesRead;
        DWORD  dwError;
        find = buf; //буфер
        // читаем одну запись
        if (!ReadFile(
            hFile,           // дескриптор файла
            buf,             // адрес буфера, куда читаем данные
            nNumberOfBytesToRead,// количество читаемых байтов
            &dwBytesRead,    // количество прочитанных байтов
            &ovl             // чтение асинхронное
        ))
        {
            switch (dwError = GetLastError())// решаем что делать с кодом ошибки
            {
                //эти ошибки смотрм после завершения асинхронной операции чтения, для возможности обработать рабочий буфер
            case ERROR_IO_PENDING: { break; }        // асинхронный ввод-вывод все еще происходит // сделаем кое-что пока он идет 
            case ERROR_HANDLE_EOF: { errHandleEOF = true;   break; } // мы достигли конца файла читалкой ReadFile
            default: {goto return1; }// другие ошибки
            }
        }
 
        //работаем асинхронно, выполняем код, пока ждем чтение с диска//
        bufWork[dwBytesReadWork] = '\0';//добавим нуль-терминатор
    goNextFind:
        if (findStatus == 0)//goFind
        {
            find = strstr(bufWorkNew, findStr);
            if (find != NULL) //если нужная подстрока найдена
            {
                for (strStart = find; strStart >= bufWorkNew; strStart--)
                {
                    if (*strStart == '\n') { break; } //если нашли начало строки
                }
                strStart++; //не учитываем '\n'
 
                strEnd = strchr(find, '\n'); //ищем конец строки
                if (strEnd != NULL) //если нашли конец строки
                {
                    strOut = strOut + std::string(strStart, strEnd - strStart + 1);
                    if (!multiLine)
                    {
                        goto return0;
                    }
                    else//поиск в следующей строке начинаем с конца предыдущей
                    {
                        bufWorkNew = strEnd++;
                        findStatus = 0;
                        goto goNextFind;
                    }
                }
                else//если конец строки в следующем буфере или конец файла
                {
                    strOut = strOut + std::string(strStart);
                    findStatus = 1;
                }
            } //если нужная подстрока найдена
        }
        else if (findStatus == 1)//goBuf
        {
            strEnd = strchr(bufWork, '\n');
            if (strEnd != NULL) //если нашли конец строки
            {
                strOut = strOut + std::string(bufWork, strEnd - bufWork + 1);
                findStatus = 0;
                if (!multiLine)
                {
                    goto return0;
                }
                else//поиск в следующей строке начинаем с конца предыдущей
                {
                    bufWorkNew = strEnd++;
                    findStatus = 0;
                    goto goNextFind;
                }
            }
            else//если конец строки в следующем буфере или конец файла
            {
                strOut = strOut + std::string(bufWork);
            }
        }
 
        //блок дозагрузки рабочего буфера межбуферной строкой
        char* bufWorkEnd = bufWork + dwBytesReadWork; //конец буфера
        for (strStart = bufWorkEnd; strStart >= bufWork; strStart--) { if (*strStart == '\n') { break; } } //если нашли начало строки
        if (strStart < bufWork && ui.QuadPart >= nNumberOfBytesToRead) { goto return1; }; //если строка больше буфера (не найден разделитель), кроме первого буфера
        strStartLen = (bufWorkEnd - ++strStart); //размер буфера, который добавляем к рабочему
        //пишем начало строки в новый буфер
        bufWorkNew = buf - strStartLen;//bufWorkNew = bufWork - strStartLen;
        memcpy(bufWorkNew, strStart, strStartLen);
        //
 
        if (errHandleEOF) { goto return0; }
        //работаем асинхронно, выполняем код, пока ждем чтение с диска//
 
        // ждем, пока завершится асинхронная операция чтения
        WaitForSingleObject(hEndRead, INFINITE);
 
        // проверим результат работы асинхронного чтения // если возникла проблема ... 
        if (!GetOverlappedResult(hFile, &ovl, &dwBytesRead, FALSE))
        {
            switch (dwError = GetLastError())// решаем что делать с кодом ошибки
            {
            case ERROR_HANDLE_EOF: { goto return0; break; }//если конец файла. но мы должны вернутся найти начало строки.
            // мы достигли конца файла в ходе асинхронной операции
            default: {goto return1; }// другие ошибки
            }// конец процедуры switch (dwError = GetLastError())
        }
 
        //меняем буфер
        char* bufTmp = bufWork;
        bufWork = buf;
        buf = bufTmp;
        //
 
        // увеличиваем смещение в файле
        dwBytesReadWork = dwBytesRead;//кол-во считанных байт
        ui.QuadPart += nNumberOfBytesToRead; //добавляем смещение к указателю на файл
        ovl.Offset = ui.LowPart;// вносим смещение в младшее слово
        ovl.OffsetHigh = ui.HighPart;// вносим смещение в старшеее слово
    }
 
return0:
    // закрываем дескрипторы, освобождаем память
    CloseHandle(hFile);
    CloseHandle(hEndRead);
    delete[] notAlignBuf;
    delete[] notAlignBufWork;
 
    OperOut->xltype = xltypeStr | xlbitDLLFree;
    if (strOut.length() > 32767)
    {
        OperOut->val.str = new XCHAR[24 + 2]; //+1 под размер + 1 под нуль-терминатор
        wcscpy(OperOut->val.str + 1, L"Overflow. Max char 32767\0");
        OperOut->val.str[0] = 24;
    }
    else
    {
        OperOut->val.str = new XCHAR[strOut.length() + 2]; //+1 под размер + 1 под нуль-терминатор
        MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, strOut.c_str(), -1, OperOut->val.str + 1, strOut.length() + 1);
        OperOut->val.str[0] = strOut.length();
    }
    return OperOut;
 
return1:
    CloseHandle(hFile);
    CloseHandle(hEndRead);
    delete[] notAlignBuf;
    delete[] notAlignBufWork;
    return OperOut;
}

if (oldMn != Mn) std::cout << Mn << std::endl;//меняем на
std::cout << Mn << std::endl;

#include <mpirxx.h>
#include <iostream>
#include <time.h>
#include <vector>
#include <thread>
 
unsigned long long Ostatok;
unsigned long long Ostatok2;
 
void Func(int start)
{
    unsigned long long Ch = (1);
    unsigned long long Mn = 30 * Ch + start;
    unsigned long long oldMn;
 
    while (Mn <= Ostatok2) {
        if (Ostatok%Mn == 0) {
            Ostatok = Ostatok / Mn;
            if (oldMn != Mn) std::cout << Mn << std::endl;
            Ostatok2 = (unsigned long long)sqrt(Ostatok);
            oldMn = Mn;
        }
        else {
            Ch++;
            Mn = 30 * Ch + start;
        }
    }
}
 
int main()
{
    std::string s;
    std::cout << "Enter the numeric for which you want to find Simple dividers, followed by <Enter>:\n";
    std::cin >> Ostatok;//s;
    std::cout << "Result:\n1" << std::endl;
    unsigned int start_time = clock(); // начальное время
    Ostatok2 = (unsigned long long)sqrt(Ostatok);
    unsigned long long Mn = (2);
    unsigned long long oldMn;
 
    while (Mn <= 30) {
        if (Ostatok%Mn == 0) {
            Ostatok = Ostatok / Mn;
            if (oldMn != Mn) std::cout << Mn << std::endl;
            Ostatok2 = (unsigned long long)sqrt(Ostatok);
            oldMn = Mn;
        }
        else { Mn++; }
    }
 
    std::vector<std::thread> thr(8);
    int arr[] = { 0,1,7,11, 13, 17, 19, 23, 29 };
    for (int i = 1; i <= 8; i++) thr[i - 1] = std::thread(Func, arr[i]);
    for (int i = 1; i <= 8; i++) thr[i - 1].join();
    if (Ostatok > 1) std::cout << Ostatok << std::endl;
    unsigned int end_time = clock(); // конечное время
    unsigned int search_time = end_time - start_time; // искомое время
    printf("\nTime, sec (min): %f (%f) \n", search_time / 1000.0, search_time / 60000.0);
    system("pause");
    return 0;
}

#include <mpirxx.h>
#include <iostream>
#include <time.h>
#include <vector>
#include <thread>
 
unsigned long long Ostatok;
unsigned long long Ostatok2;
mpz_class mpz_Ostatok;
mpz_class mpz_Ostatok2;
 
void Func(int start)
{
    unsigned long long Ch=(1);
    unsigned long long Mn = 30 * Ch + start;
    unsigned long long oldMn;
 
    while (Mn <= Ostatok2) {
        if (Ostatok%Mn == 0) {
            Ostatok = Ostatok / Mn;
            if (oldMn != Mn) std::cout << Mn << std::endl;
            Ostatok2 = (unsigned long long)sqrt(Ostatok);
            oldMn = Mn;
        }
        else{
            Ch++;
            Mn = 30 * Ch + start;
        }
    }
}
void Func2(int start)
{
    mpz_class Ch = (1);
    mpz_class Mn = 30 * Ch + start;
    mpz_class oldMn;
 
    while (Mn <= mpz_Ostatok2) {
        if (mpz_Ostatok%Mn == 0) {
            mpz_Ostatok = mpz_Ostatok / Mn;
            if (oldMn != Mn) std::cout << Mn << std::endl;
            mpz_Ostatok2 = sqrt(mpz_Ostatok);
            oldMn = Mn;
        }
        else {
            Ch++;
            Mn = 30 * Ch + start;
        }
    }
}
int main()
{
    bool mpz_Start;
    mpz_class oldMn;
    std::string s;
    std::cout << "Enter the numeric for which you want to find Simple dividers, followed by <Enter>:\n";
    std::cin >> s;//Ostatok;//s;
    std::cout << "Result:\n1" << std::endl;
    unsigned int start_time = clock(); // начальное время
    mpz_Ostatok = s;
    if (mpz_probab_prime_p(mpz_Ostatok.get_mpz_t(), 100) == 0) {
 
        std::vector<std::thread> thr(8);
        int arr[] = { 0,1,7,11, 13, 17, 19, 23, 29 };
 
        if (mpz_Ostatok > 18446744073709551615) {
            mpz_Ostatok2 = sqrt(mpz_Ostatok);
            mpz_class Mn = (2);
            mpz_class oldMn;
            while (Mn <= 30) {
                if (mpz_Ostatok%Mn == 0) {
                    mpz_Ostatok = mpz_Ostatok / Mn;
                    if (oldMn != Mn) std::cout << Mn << std::endl;
                    mpz_Ostatok2 =sqrt(mpz_Ostatok);
                    oldMn = Mn;
                }
                else { Mn++; }
            }
            for (int i = 1; i <= 8; i++) thr[i - 1] = std::thread(Func2, arr[i]);
            for (int i = 1; i <= 8; i++) thr[i - 1].join();
            if (mpz_Ostatok > 1) std::cout << mpz_Ostatok << std::endl;
        }
        else {
            Ostatok = mpz_Ostatok.get_ui();
            Ostatok2 = (unsigned long long)sqrt(Ostatok);
            unsigned long long Mn = (2);
            unsigned long long oldMn;
            while (Mn <= 30) {
                if (Ostatok%Mn == 0) {
                    Ostatok = Ostatok / Mn;
                    if (oldMn != Mn) std::cout << Mn << std::endl;
                    Ostatok2 = (unsigned long long)sqrt(Ostatok);
                    oldMn = Mn;
                }
                else { Mn++; }
            }
            for (int i = 1; i <= 8; i++) thr[i - 1] = std::thread(Func, arr[i]);
            for (int i = 1; i <= 8; i++) thr[i - 1].join();
            if (Ostatok > 1) std::cout << Ostatok << std::endl;
        }
    }
    else { std::cout << s << std::endl; }
    unsigned int end_time = clock(); // конечное время
    unsigned int search_time = end_time - start_time; // искомое время
    printf("\nTime, sec (min): %f (%f) \n", search_time / 1000.0, search_time / 60000.0);
    system("pause");
    return 0;
}

// Делители числа
//Created by ©2017, bedvit (bedvit@mail.ru)
#include <mpirxx.h>
#include <iostream>
#include <time.h>
#include <vector>
#include <thread>
#include <Windows.h>
 
CRITICAL_SECTION cs;//критическая секция
unsigned long long Ostatok;
unsigned long long Ostatok2;
unsigned long long oldMn;
unsigned long long ArrRez[3000] = {0,1};
int option;
int Solutions(1);
int y(1);
int y2(1);
mpz_class mpz_Ostatok;
mpz_class mpz_Ostatok2;
mpz_class mpz_oldMn;
mpz_class mpz_ArrRez[100000] = { 0,1 };
 
void Func(int start)
{
    unsigned long long Ch=(1);
    unsigned long long Mn = 30 * Ch + start;
    while (Mn <= Ostatok2) {
        if (Ostatok%Mn == 0) {
        EnterCriticalSection(&cs);//критическая секция
        Ostatok = Ostatok / Mn;
        Ostatok2 = (unsigned long long)sqrt(Ostatok);
            if (option == 3) {
                if (oldMn != Mn) {
                    for (y = 1; y <= Solutions; y++) {
                    ArrRez[Solutions + y] = ArrRez[y] * Mn;
                    std::cout << ArrRez[Solutions + y] << std::endl;
                    }
                Solutions = Solutions + y - 1;
                    }
                else {
                    for (y2 = 1; y2 < y; y2++) {
                    ArrRez[Solutions + y2] = ArrRez[Solutions - y + 1 + y2] * Mn;
                    std::cout << ArrRez[Solutions + y2] << std::endl;
                    }
                Solutions = Solutions + y2 - 1;
                }
            }
            else if (oldMn != Mn || option != 2) { Solutions++; std::cout << Mn << std::endl; } //или
        oldMn = Mn;
        LeaveCriticalSection(&cs);//критическая секция
        }
        else{Ch++;Mn = 30 * Ch + start;}
    }
}
void Func2(int start)
{
    mpz_class mpz_Ch = (1);
    mpz_class mpz_Mn = 30 * mpz_Ch + start;
    while (mpz_Mn <= mpz_Ostatok2) {
        if (mpz_divisible_p(mpz_Ostatok.get_mpz_t(), mpz_Mn.get_mpz_t())==0){mpz_Ch++;mpz_Mn = 30 * mpz_Ch + start;}//проверка на делимость
        else {
        EnterCriticalSection(&cs);//критическая секция
        mpz_Ostatok = mpz_Ostatok / mpz_Mn;
        mpz_Ostatok2 = sqrt(mpz_Ostatok);
            if (option == 3) {//проверка на выбранную опцию
                if (mpz_oldMn != mpz_Mn) {
                    for (y = 1; y <= Solutions; y++) {
                    mpz_ArrRez[Solutions + y] = mpz_ArrRez[y] * mpz_Mn;
                    std::cout << mpz_ArrRez[Solutions + y] << std::endl;
                    }
                Solutions = Solutions + y - 1;
                }
                else {
                    for (y2 = 1; y2 < y; y2++) {
                    mpz_ArrRez[Solutions + y2] = mpz_ArrRez[Solutions - y + 1 + y2] * mpz_Mn;
                    std::cout << mpz_ArrRez[Solutions + y2] << std::endl;
                    }
                Solutions = Solutions + y2 - 1;
                }
            }
            else if (mpz_oldMn != mpz_Mn || option != 2) { Solutions++; std::cout << mpz_Mn << std::endl; } //или
        mpz_oldMn = mpz_Mn;
        LeaveCriticalSection(&cs);//критическая секция
        }
    }
}
int main()
{   InitializeCriticalSection(&cs);
    ////////////////////вывод большого количества строк в консоль
    HANDLE  hout = GetStdHandle(STD_OUTPUT_HANDLE);
    COORD  size;
    size.X = 100;   // кол-во символов на строку
    size.Y = 10010;  // увеличиваем до нужного размера - количества переменных
    SetConsoleScreenBufferSize(hout, size);
    ////////////////////
    std::string s;
    std::cout << "Created by 2017, bedvit (bedvit@mail.ru)\n\nFactorization of a number(factorization)=1\nSearch for prime divisors=2\nSearch for all divisors=3\nSelect a calculation option:= ";
    std::cin >> option;
    std::cout << "Enter the numeric: ";
    std::cin >> s;
    std::cout << "\nResult:\n1" << std::endl;
    unsigned int start_time = clock(); // начальное время
    mpz_Ostatok = s;
    if (mpz_probab_prime_p(mpz_Ostatok.get_mpz_t(), 100) == 0) {
 
        std::vector<std::thread> thr(8);
        int arr[] = { 0,1,7,11, 13, 17, 19, 23, 29 };
 
        if (mpz_Ostatok > 18446744073709551615) {
            mpz_Ostatok2 = sqrt(mpz_Ostatok);
            mpz_class mpz_Mn = (2);
            mpz_class mpz_oldMn;
            while (mpz_Mn <= 30) {
                if (mpz_divisible_p(mpz_Ostatok.get_mpz_t(), mpz_Mn.get_mpz_t()) == 0) { mpz_Mn++;}  //проверка на делимость
                else {
                    mpz_Ostatok = mpz_Ostatok / mpz_Mn;
                    mpz_Ostatok2 = sqrt(mpz_Ostatok);
 
                    if (option == 3) {//проверка на выбранную опцию
                        if (mpz_oldMn != mpz_Mn) {
                            for (y = 1; y <= Solutions; y++) {
                                mpz_ArrRez[Solutions + y] = mpz_ArrRez[y] * mpz_Mn;
                                std::cout << mpz_ArrRez[Solutions + y] << std::endl;
                            }
                            Solutions = Solutions + y - 1;
                        }
                        else {
                            for (y2 = 1; y2 < y; y2++) {
                                mpz_ArrRez[Solutions + y2] = mpz_ArrRez[Solutions - y + 1 + y2] * mpz_Mn;
                                std::cout << mpz_ArrRez[Solutions + y2] << std::endl;
                            }
                            Solutions = Solutions + y2 - 1;
                        }
                    }
                    else if (mpz_oldMn != mpz_Mn || option != 2) { Solutions++; std::cout << mpz_Mn << std::endl; } //или
                    mpz_oldMn = mpz_Mn;
                }
            }
            for (int i = 1; i <= 8; i++) thr[i - 1] = std::thread(Func2, arr[i]);
            for (int i = 1; i <= 8; i++) thr[i - 1].join();
            if (mpz_Ostatok > 1){//проверяем остаток
                if (option == 3) {
                    if (mpz_oldMn != mpz_Ostatok) {
                        for (y = 1; y <= Solutions; y++) {
                            mpz_ArrRez[Solutions + y] = mpz_ArrRez[y] * mpz_Ostatok;
                            std::cout << mpz_ArrRez[Solutions + y] << std::endl;
                        }
                        Solutions = Solutions + y - 1;
                    }
                    else {
                        for (y2 = 1; y2 < y; y2++) {
                            mpz_ArrRez[Solutions + y2] = mpz_ArrRez[Solutions - y + 1 + y2] * mpz_Ostatok;
                            std::cout << mpz_ArrRez[Solutions + y2] << std::endl;
                        }
                        Solutions = Solutions + y2 - 1;
                    }
                }
                else { std::cout << mpz_Ostatok << std::endl; Solutions++; }
            }
        }
        else {
            Ostatok = mpz_Ostatok.get_ui();
            Ostatok2 = (unsigned long long)sqrt(Ostatok);
            unsigned long long Mn = (2);
            unsigned long long oldMn;
            while (Mn <= 30) {
                if (Ostatok%Mn == 0) {//проверка на делимость
                    Ostatok = Ostatok / Mn;
                    Ostatok2 = (unsigned long long)sqrt(Ostatok);
                    
                    if (option == 3) {//проверка на выбранную опцию
                        if (oldMn != Mn) {
                            for (y = 1; y <= Solutions; y++) {
                                ArrRez[Solutions + y] = ArrRez[y] * Mn; 
                                std::cout << ArrRez[Solutions + y] << std::endl; 
                            }
                        Solutions = Solutions + y-1;
                        }
                        else {
                            for (y2 = 1; y2 < y; y2++) { 
                                ArrRez[Solutions + y2] = ArrRez[Solutions - y + 1 + y2] * Mn; 
                                std::cout << ArrRez[Solutions + y2] << std::endl;
                            }
                            Solutions = Solutions + y2 - 1;
                        }
                    }
                    else if (oldMn != Mn || option != 2){Solutions++;std::cout << Mn << std::endl;} //или
                    oldMn = Mn;
                }
                else { Mn++; }
            }
            for (int i = 1; i <= 8; i++) thr[i - 1] = std::thread(Func, arr[i]);
            for (int i = 1; i <= 8; i++) thr[i - 1].join();
            if (Ostatok > 1) {//проверяем остаток
                if (option == 3) {
                    if (oldMn != Ostatok) {
                        for (y = 1; y <= Solutions; y++) {
                            ArrRez[Solutions + y] = ArrRez[y] * Ostatok;
                            std::cout << ArrRez[Solutions + y] << std::endl;
                        }
                        Solutions = Solutions + y - 1;
                    }
                    else {
                        for (y2 = 1; y2 < y; y2++) {
                            ArrRez[Solutions + y2] = ArrRez[Solutions - y + 1 + y2] * Ostatok;
                            std::cout << ArrRez[Solutions + y2] << std::endl;
                        }
                        Solutions = Solutions + y2 - 1;
                    }
                }
                else { std::cout << Ostatok << std::endl; Solutions++; }
            }
        }
    }
    else { std::cout << s << std::endl; Solutions++;}//если число простое
    unsigned int end_time = clock(); // конечное время
    unsigned int search_time = end_time - start_time; // искомое время
    printf("\nTime, sec (min): %f (%f) Solutions: %u\n", search_time / 1000.0, search_time / 60000.0, Solutions);
    system("pause");
    return 0;
}