/*Задан текстовый файл Input.txt , в котором записана последовательность некоторых
слов, разделенных  одним или несколькими разделителями из заданного множества
разделителей [пробел,  точка, запятая, точка с запятой, двоеточие, плюс].
1.  Найти все слова-числа, т.е. такие, которые состоят только из цифр. Известно,
что количество цифр в каждом числе не более 9 (девяти).
a.   Для проверки, является ли слово числом использовать функцию (С++)
2.  Найденные слова-числа записать  в динамический массив DArray.
3.  Получить новый массив NewArray, преобразовав каждое число динамического
массива в  наименьшее число, составленное из его цифр.
a.  Для преобразования числа в наименьшее использовать функцию (С++Рекурсию***)
4.  Найти наименьшее Min и наибольшее Max  числа  у полученного массива NewAarray.
a.  Для нахождения  наименьшего и наибольшего в массиве использовать функции С++,
алгоритм поиска должен быть реализован  на Ассемблере.
5.  Получить динамическую матрицу Matr, количество строк которой будет равно
количеству чисел массива Darray,    меньших Max и больших  Min.
a.  В первый столбец  записать сами числа, во второй их номера в массиве Darray и
в третий - сумму их цифр.
6.  Найти сумму строки матрицы, номер которой вводит пользователь.
a.  Для нахождения суммы строки использовать подпрограмму (Assemble)
7.  Все промежуточные результаты в процессе решения задачи записать в текстовый
файл.*/




#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

void breakup(char str[], int* a, int *x)   // для разбиения и засылки чисел
{
    char sep[]=" .,:;+";
    char letter[]="АБВГДЕЖЗИКЛМНОПРСТУФХЧШЩЭЮЯабвгдежзийклмнопрстуфхцчшщъыьэюяQWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm";
    char *p;
    int n;
    p=strtok(str,sep);
    if (!p)
        return;
    n=atoi(p);
    if(n && (!strpbrk(p,letter)))
    {
        (*x)++;
        a[*x-1]=n;
    }

    while (p)
    {
        p=strtok(NULL, sep);
        if (!p)
            break;
        n=atoi(p);
        if (n && (!strpbrk(p,letter)))
        {
            (*x)++;
            a[*x-1]=n;

        }

    }

}
void sortinsert(int* array_, int dimension)
{
    _asm
    {
        mov ecx, dimension
        dec ecx
        mov eax, array_
        mov esi,1
fr_out: push ecx
        mov edx,[eax][esi*4]
        mov ecx,esi
        mov edi,esi
        dec edi
for_in: cmp edx,[eax][edi*4]
        jnl end_in
        mov ebx,[eax][edi*4]
        mov [eax][edi*4+4],ebx
        dec edi
        loop for_in
end_in: mov [eax][edi*4+4],edx
        inc esi
        pop ecx
        loop fr_out
    }
}
int binsearch(int a[], int dim, int key)
{
    int index;
    _asm
    {
        mov eax,key
        mov ebx, a
        mov esi,dim
        xor edi,edi

beg_c:  cmp edi,esi
        jg end_f
        mov edx,esi
        add edx,edi
        shr edx,1
        cmp eax,[ebx][edx*4]
        je end_tr
        jl less
        mov edi,edx
        inc edi
        jmp beg_c
less:   mov esi,edx
        dec esi
        jmp beg_c
end_f:  mov index,-1
        jmp end
end_tr: mov index,eax
end:    nop
    }
    return index;
}


void makearr(int el, int b[], int *n)  // число засылаем по цифрам в массив запоминаем количество цифер
{                                    //для выебона на ассемблере
    _asm
    {
        xor esi,esi
        mov eax,el
        cdq
        mov edi,b
l_beg:
        mov ebx,10
        div ebx
        mov [edi][esi*4],edx
        test eax,eax
        je end_l
        inc esi
        cdq
        jmp l_beg
end_l:  inc esi
        mov edi,n
        mov [edi],esi
        mov ecx,esi
        dec ecx
loop1:  push ecx
        mov esi,b
loop2:  mov eax,[esi]
        cmp eax,[esi+4]
        jge then
        xchg eax,[esi+4]
        mov [esi],eax
then:   add esi,4
        loop  loop2
        pop  ecx
        loop loop1
    }

}
void movmin(int *el, int b[], int n)   //делаем из числа минимум, засылаем в нужный новый массив
{
    int a;
    a=b[n-1]*(int)pow(10.0,n-1);
    (*el)+=a;
    if(n==1)
        return;
    movmin(el,b,n-1);
}
void makemin(int *src, int *dest, int n)    //две пред. функции в одну, для экономии места
{
    int b[9],m;
    for (int i=0; i<n; i++)
    {
        makearr(src[i],b, &m);
        dest[i]=0;
        movmin(&dest[i],b,m);
    }
}

void minmax(int *a, int n, int *min, int *max)
{
    _asm
    {
        mov eax,a
        mov ebx,[eax] //min
        mov edx,[eax] //max
        mov esi,1
        mov ecx,n
        dec ecx
for_1:  jcxz e
        cmp edx,[eax][esi*4]
        jge for_in
        mov edx,[eax][esi*4]
for_in: cmp ebx,[eax][esi*4]
        jle end_1
        mov ebx,[eax][esi*4]
end_1:  inc esi
        loop for_1
e:      mov eax,min
        mov [eax],ebx
        mov eax,max
        mov [eax],edx
    }
}
int sum(int a)
{
    int sum;
    _asm
    {
        xor esi,esi
        mov eax,a
        cdq
l_beg:
        mov ebx,10
        div ebx
        add esi,edx
        test eax,eax
        je end_1
        cdq
        jmp l_beg
end_1:  mov sum,esi
    }
    return sum;
}
int sumstr(int **a, int i, int n)
{
    int sum;
    _asm
    {
        mov eax,a
        mov esi,i
        shl esi,2
        add eax,esi
        mov ebx,[eax]
        mov ecx,n
        xor esi,esi
        xor edi,edi
for_1:
        mov eax,[ebx][edi*4]
        cdq
        push ecx
l_beg:
        mov ecx,10
        div ecx
        add esi,edx
        test eax,eax
        je end_1
        cdq
        jmp l_beg
end_1:  pop ecx

        inc edi
        loop for_1
        mov sum,esi
    }
    return sum;
}


void main()
{
    const int m=3;
    FILE *in, *out;
    int a[400];
    int *d, *c, **mat;
    char str[1000];
    int n=0,i,j, min, max,i_min, i_max;
    gets(str);
    breakup(str,a,&n);
    for (i=0; i<n; i++)
        printf("%d ", a[i]);
    d=(int*)malloc(n*sizeof(int));
    c=(int*)malloc(n*sizeof(int));
    for (i=0; i<n; i++)
        d[i]=a[i];
    makemin(d,c,n);
    printf("\n");
    for (i=0; i<n; i++)
        printf("%d ", c[i]);
    minmax(c,n,&min, &max);
    j=0;
    printf("\n\n");
    for (i=0; i<n; i++)
    {
        if (a[i]>min && a[i]<max)
            j++;
    }
    mat=(int**)malloc(j*sizeof(int*));
    for (i=0; i<j; i++)
        *(mat+i)=(int*)malloc(m*sizeof(int));
    int t=0;
    for (i=0; i<j; i++)
    {

        for (int k=t; k<n; k++)
        {
            if (a[k]>min && a[k]<max)
            {
                mat[i][0]=a[k];
                mat[i][1]=k+1;
                mat[i][2]=sum(a[k]);
                t=k+1;
                break;
            }
            //t++;

        }
    }
    for (i=0; i<j; i++)
    {
        for (int k=0; k<m; k++)
            printf("%d ", mat[i][k]);
        printf("\n");
    }

    int stroka;
    scanf("%d", &stroka);
    int z;
    --stroka;
    z=sumstr(mat,stroka,m);
    printf("%d\n", z);
}