void algorithm12ryad(double mass[], double x, int n, double epsilon, double d)
{
    int i = 1;
    int two = 2;
    int one = 1;
    int maxsumn = 1000;
    __asm {
        mov ecx, n
        mov eax, maxsumn
        inc eax
        mov ebx, mass
        xor edx, edx
        xor si, si
        finit
        fld epsilon             // st4  epsilon точность
        fld1                    // st3  1 для хранение константы 1
        fld x                   // st2  x
        fld1                    // st1  1 для хранения суммы n-1 членов
        fldz                    // st0  0 для вычислений
        fldz
        fincstp                 // st7 0
bigcycle:
sumcycle:
        fiadd i                 // st(0) = i         команда сопроцессора, для суммирования регистра с целочисленным значением fadd для вещественного.
        fadd st(0), st(3)       // st(0) = i + 1
        fmul st(0), st(2)       // (i+1) x^i  a i-ый элемент
        fincstp
        fchs                    // изменим знак суммы. таким образом получим при i чёт - (i+1)^i x сложится, а при неч вычтется в конце программы поменяем знак результата.
        fdecstp
        fadd st(1), st(0)       // добавим к сумме в st(1), st(0) то есть(i+1) x^2

        inc [i]                 // инкремент i
        not si                  // флаг изменения знака для чётного количества элементов нужно изменять, для нечётного нет.
        cmp eax, i              // сравнение (eax, i)
        jbe exit1               // (n<=i)?


        //fadd st(0), st(1)     // копируем в st(0) сумму
        fabs                    // модуль числа st(0) = abs(st(0))
        fucom st(4)             // сравнение с вершиной стека значения источника.  если дописать p
        fstsw   ax              // С помощью команды "FSTSW AX" программа может переписать содержимое регистра состояния сопроцессора в регистр AX центрального процессора.
        sahf                    // содержимое регистра AH можно переписать в регистр флагов центрального процессора при помощи команды SAHF. можно использовать стандартные команды перехода je, ja, etc.

        fsub st(0), st(0)       // обнуление вершины
        fincstp                 // уменьшает указатель стека на 1
        fincstp
        fmul st(0), st(0)       // x*x на каждом шаге
        fdecstp
        fdecstp                 // увеличивает указатель стека на 1

        jbe exit1

        jmp sumcycle
exit1:
        fincstp

        cmp si, 0
        je nochange
        fchs
        nochange:
        fst QWORD PTR [ebx + edx*8]         //команда сохранения значения из вершины стека в память, не сдвигая стек. для вещественного.

        fsub st(0), st(0)
        fadd st(0), st(2)
        fincstp
        fsub st(0), st(0)
        fadd x
        fadd d
        fst x
        fdecstp
        fdecstp

        inc edx
        mov [i], 1
        xor si, si
    loop bigcycle
    }
}

void algorithm12func(double mass[], double x, int n, double d) {
    _asm {
        finit
        mov ecx, n          // в ecx n = количество повторений или длина массива
        mov ebx, mass       // в ebx адрес массива для результирующих значений
        xor edx, edx        // в edx номер текущего элемента массива
        fld d               // загрузка x
        fld1                // загружает единицу
    bigcycle:
        fld x               // загружает x st(0) = x
        fadd st(0), st(1)   // x(st(0)) = x(st(0)) + 1(st(1))
        fmul st(0), st(0)   // (x+1)^2
        fdivr st(0), st(1)  // st(0) = st(1)/st(0) так как есть постфикс xxxxr по умолчанию st(0) = st(0)/st(1)

        fstp QWORD PTR [ebx + edx*8] // записываем в массив получившиеся значения.
        fld x                        // загружаем x для прибавления шага d
        fadd st(0), st(2)            // прибавляем шаг
        fstp x                       // fstp - выгружает данные в память, извлекая вершину стека.
        inc edx                      // индекс массива.
        loop bigcycle
    }
}

double RootMeanSquareError(double *mass1, double *mass2, int n)
{
    double result = 0;
    _asm {
        mov ecx, n
        mov eax, mass1
        mov ebx, mass2
        xor edx, edx
        finit
        fldz
cycle:
            fld QWORD PTR [ebx + edx*8]
            fld QWORD PTR [eax + edx*8]
            fsub st(0), st(1)               // mass2[i] - mass1[i]
            fmul st(0), st(0)               // (mass2[i] - mass1[i])^2
            fadd st(2), st(0)               // st(2) - сумма += (mass2[i] - mass1[i])^2
            fstp result                     // дибильная операция по извлечению верхушки стека. дибильная, потому что ещё и записывает в память.
            fstp result
            inc edx
        loop cycle
        fild n                              // загружаем n
        fdivr st(0), st(1)                  // summ/n b помещаем в st(0)
        fsqrt                               // sqrt(st(0))
        fst result
    }
    return result;
}

int _tmain(int argc, _TCHAR* argv[])
{
    int leng = 0;
    double *mass1 = new double[leng];
    double *mass2 = new double[leng];
    double x = 0.120796;
    double epsilon = 0.05;
    double step = 0.05;
    while (1)
    {
        printf("n = ");
        scanf("%i", &leng);
        printf("\nx = ");
        scanf("%f", &x);
        printf("\nepsilon = ");
        scanf("%f", &epsilon);
        printf("\nstep = ");
        scanf("%f", &step);
        algorithm12func(mass2, x, leng, step);
        algorithm12ryad(mass1, x, leng, epsilon, step);
        printf("\nYour result:\n");
        for(int i = 0; i < leng; i++)
        {
            printf("ryad(%f) - %i - %e\n", x + i*step, i+1, mass1[i]);
            printf("func(%f) - %i - %e\n\n", x + i*step, i+1, mass2[i]);
        }
        printf("RootMeanSquareError %e\n\n", RootMeanSquareError(mass1, mass2, leng)); getch();
    }
    return 0;
}