format PE GUI 4.0
entry start

include 'C:\fasmw17304\INCLUDE\win32a.inc'

BUFFER_SIZE     = 255
;MODUL           = 10


section '.data' data readable writeable
        num1 db BUFFER_SIZE dup(?)
        num2 db BUFFER_SIZE dup(?)
        res db BUFFER_SIZE dup(0)
        mulBuf db BUFFER_SIZE dup(0)
        modul db BUFFER_SIZE dup(?)

        num1FileName db 'C:\111\num1.txt',0
        num2FileName db 'C:\111\num2.txt',0
        resFileName db 'C:\111\res.txt',0
        modFileName db 'C:\111\mod.txt',0

        lpBytesNum1 dd ?
        lpBytesNum2 dd ?
        lpBytesMod dd ?
        lpBytesRes dd ?
        hFile dd ?

section '.code' code readable executable
        proc OpenAndRead, fn ,buf ,bufSize, bytesRead
             push    eax
             invoke CreateFile, [fn], GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0
             mov [hFile], eax

             ;invoke  GetFileSize, [hFile], 0
             ;mov [fSize], eax

             invoke ReadFile, [hFile], [buf], [bufSize], [bytesRead], 0
             invoke CloseHandle, [hFile]

             pop     eax
             ret
        endp

        proc OpenAndWrite, fn, buf, bufSize, bytesRead
             push    eax
             invoke CreateFile, [fn], GENERIC_WRITE, FILE_SHARE_WRITE, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0
             mov [hFile], eax

             ;invoke  GetFileSize, [hFile], 0
             ;mov [fSize], eax

             invoke WriteFile, [hFile], [buf], [bufSize], [bytesRead], 0
             invoke CloseHandle, [hFile]

             pop     eax
             ret
        endp

        proc ByteAdd, res, numberLen, add_byte
             push eax edi ecx
             pushf
             cld
             clc
             mov ah, byte[add_byte]

             mov ecx, [numberLen]
             mov edi, [res]
             .loop:
                mov al, ah
                add al, [edi]
                jc .over
                stosb
                jmp .end
             .over:
                mov ah, 1
                stosb
             loop .loop
             .end:
                popf
                pop ecx edi eax
             ret
        endp


        ;СУММА

        proc Sum, number1, number2, result, numberLen
             push ax edi ecx
             cld
             clc
             mov ecx, [numberLen]
             .loop:
                mov edi, [number1]
                mov al,  [edi]
                mov edi, [number2]
                jc .over
                add al, [edi]
                jmp .save_digit
              .over:
                add al, 1
                jc .over_again
                add al, [edi]
                jmp .save_digit
              .over_again:
                mov al, [edi]
              .save_digit:
                mov edi, [result]
                mov [edi], al
                inc [number1]
                inc [number2]
                inc [result]
             loop .loop


             pop ecx edi ax
             ret
        endp

        ; СДВИГ ВЛЕВО - *2

       proc ShiftLeft, number, numberLen
             push esi ecx eax
             pushf
             cld
             clc
             mov ecx, [numberLen]
             mov esi, [number]
             lodsb
             mov ah, al
             shr ah, 7
             shl al, 1
             mov [esi-1], al
             dec ecx
             .loop:
                 lodsb
                 mov [esi-1], ah
                 mov ah, al
                 shr ah, 7
                 shl al, 1
                 add [esi-1], al
             loop .loop
             popf
             pop eax ecx esi
             ret
        endp

        ;Вычитание (мемное)

        proc TrueSub, number1, number2, result, numberLen
        pusha



        mov cx, 0
        sub1:
                mov eax, [numberLen]
                cmp cx, ax
                jz exit_sub

                xor ax, ax

                sub_lbl1:
                mov dx, 256
                sub dx, ax
                mov ax, dx
                mov edi, [number1]
                mov dl, [edi]
                add ax, dx
                mov edi, [number2]
                mov dl, [edi]
                sub ax, dx
                cmp ax, 255
                jg sub_lbl2

                mov edi, [result]
                ;mov dl, 'o'
                mov [edi], al
                ;mov [edi], dl
                inc cx
                inc [number1]
                inc [number2]
                inc [result]

                jmp sub2
                sub_lbl2:
                mov edi, [result]
                ;mov dl, 'x'
                mov [edi], al
                ;mov [edi], dl
                inc cx
                inc [number1]
                inc [number2]
                inc [result]

                jmp sub1
                sub2:
                mov ax, 1d
                jmp sub_lbl1
                 exit_sub:
        popa
        ret
        endp


        ;  Перебор по всем битам со старшего



        proc ModularMul, number1, number2, result, numberLen, modulus

             push eax edi ecx
             pushf
             stdcall Remodulate, [number1], [result], [numberLen], [modulus]
             stdcall Remodulate, [number2], [result], [numberLen], [modulus]
             mov ecx, [numberLen]
             mov edi, [number1]
             add edi, [numberLen]
             dec edi

             .loop:
                cmp ecx, 0
                je .exit_loop
                ;xor ax, ax
                ;mov al, [edi]
                push ecx
                mov ecx, 8d

                .loopa:
                    stdcall ShiftLeft, [result], [numberLen]

                    stdcall Less, [result], [modulus], [numberLen]
                    cmp eax, 0
                    jne .less
                    stdcall TrueSub, [result], [modulus], [result], [numberLen]
                    .less:

                    xor ax, ax
                    mov al, [edi]

                    mov bx, 1
                    shl bx, cl
                    shr bx, 1
                    test ax, bx


                    jz .endif
                    stdcall Sum, [result], [number2], [result], [numberLen]
                    .endif:

                    stdcall Less, [result], [modulus], [numberLen]
                    cmp eax, 0
                    jne .less2
                    stdcall TrueSub, [result], [modulus], [result], [numberLen]
                    .less2:

                loop .loopa

                pop ecx
                dec edi
                dec ecx
             jmp .loop

             .exit_loop:

             popf
             pop ecx edi eax
             ret

        endp

        proc Remodulate, number, result, numberLen, modulus
             pusha
             .loop:
                stdcall Less, [number], [modulus], [numberLen]
                cmp eax, 0
                jne .exit
                stdcall TrueSub, [number], [modulus], [number], [numberLen]
                jmp .loop
             .exit:
             popa
             ret
        endp

        proc ClearArray array, numberLen
             pusha
                mov ecx, [numberLen]
                mov edi, [array]
                @clearloop:
                    mov [edi],BYTE  0
                    inc edi
                loop @clearloop
             popa
             ret
        endp

        proc CopyArray source, dest, numberLen
            pusha

            mov ecx, [numberLen]
            .copyloop:
            mov edi, [source]
            mov al, [edi]
            mov edi, [dest]
            mov [edi], al
            inc [source]
            inc [dest]
            loop .copyloop

            popa
            ret
        endp

        proc ModularExponentiation number1, number2, result, numberLen, modulus, buffer

           push eax edi ecx
             pushf
             mov ecx, [numberLen]
             mov edi, [number2]
             add edi, [numberLen]
             dec edi
             mov [res], 1

             .loop:
                cmp ecx, 0
                je .exit_loop
                ;xor ax, ax
                ;mov al, [edi]
                push ecx
                mov ecx, 8d

                .loopa:
                    ;stdcall ShiftLeft, [result], [numberLen]

                    ;stdcall Less, [result], [modulus], [numberLen]
                    ;cmp eax, 0
                    ;jne .less
                    ;stdcall TrueSub, [result], [modulus], [result], [numberLen]
                    ;.less:
                    ;ModularMul, number1, number2, result, numberLen, modulus
                   ; proc CopyArray source, dest, numberLen
                   ;  proc ClearArray array, numberLen
                    stdcall ClearArray, [buffer], [numberLen]
                    stdcall ModularMul, [result], [result], [buffer], [numberLen], [modulus]
                    stdcall CopyArray, [buffer], [result], [numberLen]
                    ;stdcall ClearArray, [buffer], [numberLen]

                    xor ax, ax
                    mov al, [edi]

                    mov bx, 1
                    shl bx, cl
                    shr bx, 1
                    test ax, bx


                    jz .endif
                    stdcall ClearArray, [buffer], [numberLen]
                    ;stdcall Sum, [result], [number2], [result], [numberLen]
                    stdcall ModularMul, [result], [number1], [buffer], [numberLen], [modulus]
                    stdcall CopyArray, [buffer], [result], [numberLen]
                    ;stdcall ClearArray, [buffer], [numberLen]
                    .endif:

                    ;stdcall Less, [result], [modulus], [numberLen]
                    ;cmp eax, 0
                    ;jne .less2
                    ;stdcall TrueSub, [result], [modulus], [result], [numberLen]
                    ;.less2:

                loop .loopa

                pop ecx
                dec edi
                dec ecx
             jmp .loop

             .exit_loop:

             popf
             pop ecx edi eax
             ret


        endp


       proc Less, number1, number2, numberLen
             push edi esi ecx ebx
             pushf
             mov ecx, [numberLen]
             mov edi, [number1]
             add edi, [numberLen]
             dec edi

             mov esi, [number2]
             add esi, [numberLen]
             dec esi
             .loop:
                mov bl, [edi]
                mov bh, [esi]
                cmp bl, bh
                jb .end_true
                ja .end_false
                dec edi
                dec esi
             loop .loop
             .end_false: ;;equal or greater
             mov eax, 00h
             jmp .exit
             .end_true:
             mov eax, 01h
             .exit:
             popf
             pop ebx ecx esi edi
             ret
        endp

        start:
             stdcall OpenAndRead, num1FileName, num1, BUFFER_SIZE, lpBytesNum1
             stdcall OpenAndRead, num2FileName, num2, BUFFER_SIZE, lpBytesNum2
             stdcall OpenAndRead, modFileName, modul, BUFFER_SIZE, lpBytesMod

             ;stdcall Less, num1, num2, BUFFER_SIZE
             ;stdcall Subs, num1, num2, res, BUFFER_SIZE

             ;stdcall Bits, num1, res, 10d

            ; stdcall ModularMul, num1, num2, res, BUFFER_SIZE, modul
           ; proc ModularExponentiation number1, number2, result, numberLen, modulus, buffer
             stdcall ModularExponentiation, num1, num2, res, BUFFER_SIZE, modul, mulBuf

             stdcall OpenAndWrite, resFileName, res, BUFFER_SIZE, lpBytesRes
             invoke ExitProcess, 0

section '.idata' import data readable writeable

        library kernel,'KERNEL32.DLL'

        import  kernel,\
                CreateFile, 'CreateFileA',\
                WriteFile, 'WriteFile',\
                ReadFile, 'ReadFile',\
                CloseHandle, 'CloseHandle',\
                ExitProcess,'ExitProcess'