#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
        int result;
        int remainder;
        int divisor = 0x10;

        __asm
        {
                mov eax, 51h
                xor edx,edx
                div divisor
                mov [result],eax
                mov [remainder],edx
        }

        cout << "Result: " << result << " Remainder: " << remainder << endl;

        return 0;
}

    

OK,I'm not sure about this,but I'll try. Thanks.

include '%fasminc%\win32a.inc'
format PE console ; we want console program
entry main

section '.data' data readable writeable ;our variables
msg1 db 'Type the number: ',0

num1 dd 0

frmt1 db '%d',0
frmt2 db 'The result of the division is %d and the remainder is %d!',0

res dd 0
rem dd 0

section '.code' code readable executable ; our code
main:
        cinvoke printf,msg1     ; we print the first message
        cinvoke scanf,frmt1,num1; we read the number
        
        
        mov eax,[num1] ; we store the number in eax
        xor edx,edx
        mov ecx,2          ; we move 2 into ecx
        div ecx    ; do the division
        
        mov [res],eax   ; we get
        mov [rem],edx   ; the results
        cinvoke printf,frmt2,[res],[rem] ; we print the results

        
        invoke ExitProcess,0   ; we Exit the program

section '.idata' import data readable writeable ; our import section

  library kernel32,'kernel32.dll',\
          msvcrt,'msvcrt.dll'

  import kernel32,\
         ExitProcess,'ExitProcess'

  import msvcrt,\          ; Functions from C library
         printf,'printf',\
         scanf,'scanf'
    

include 'win32a.inc'
;include 'win32w.inc'
;include 'encoding\utf8.inc'

format PE console
entry main

section '.code' code readable executable
main:
        cinvoke printf,msg1            ;Demande du dividende
        cinvoke scanf,frmt1,_val1
        
        cinvoke printf,msg2            ;Demande du diviseur
        cinvoke scanf,frmt1,_val2

        xor     eax, eax
        mov     edx, 0                 ;obligatoire avant de faire la division (signe)
        mov     eax, dword [_val1]
        test    eax, eax               ;positionne le flag (pour vérifier le signe)
        js      negatif                ;il y a un signe ? oui donc saut
        jmp     cont
  negatif:
        mov     edx, -1                ;obligé, pour indiquer qu'il y a un signe négatif
  cont:
        mov     ebx, dword [_val2]
        idiv    ebx
        mov     dword [result], eax
        mov     dword [reste], edx     ;le reste de la division

        ;on affiche le résultat
        cinvoke printf,frmt2,[result],[reste]

        invoke  ExitProcess,0          ;On quitte

section '.data' data readable writeable
msg1    db 'Entrez le dividende : ',0
msg2    db 'Entrez le diviseur  : ',0

frmt1   db '%d',0
frmt2   db 'Le résultat de la division est : %d',13,10,\
           '                  le reste est : %d',0

_val1   dd 0
_val2   dd 0

result  dd 0
reste   dd 0

section '.idata' import data readable writeable

  library kernel32,'kernel32.dll',\
          msvcrt,'msvcrt.dll'

  import kernel32,\
         ExitProcess,'ExitProcess'

  import msvcrt,\
         printf,'printf',\
         scanf,'scanf'    

        proc IsPrime,Value

                        mov eax,[Value]

                        cmp eax,0x00000001
                        je IsPrime_False

                        cmp eax,0x00000002
                        je IsPrime_True

                        and eax,0x00000001
                        cmp eax,0
                        je IsPrime_False

                        xor ecx,ecx
                        inc ecx

                 IsPrime_Do:

                        add ecx,2

                        mov eax,[Value]
                        xor edx,edx
                        div ecx
                        cmp edx,0
                        je IsPrime_False

                        mov eax,[Value]
                        shr eax,1
                        add eax,2
                        cmp ecx,eax
                        jae IsPrime_True

                        jmp IsPrime_Do

                 IsPrime_True:

                        xor eax,eax
                        not eax

                        jmp IsPrime_Exit

                 IsPrime_False:

                        xor eax,eax

                 IsPrime_Exit:

             endp
    

To divide by 3 with just bitwise operators