Zadanie 1:

    C:
    if (we == 0x7E) // 0x7E = 0111 1110
        wy = 0;
    else
        wy = 1;
-------------------------------------------------------------------------
    Assembler:
    mov al, we // Wrzucam we na rejestr al (8 bitowy bo char to zmienna 8 bitowa)
    mov bl, 0 // Wrzucam 0 na rejestr bl
    add al, 0x82 // Zamieniam liczbę 0x7E na liczbę ujemną - neguje oraz dodaje 1: 0x82 = 1000 0010
    jz etykieta1 // Jeżeli zero to skaczę do etykiety1 (liczby są sobie równe)
    add bl, 1 // Wrzucam 1 na rejestr bl gdy liczby nie są sobie równe
    etykieta1:
    mov wy, bl // Zawartość rejestru przerzucam do zmiennej wy (0 lub 1)
=========================================================================
Zadanie 2:

    C:
    unsigned char we, wy;
    if (we < 0xCF) // 0xCF = 1100 1111
        wy = 0;
    else
        wy = 1;

    //0xCFh = 1100 1111
    //0x31h = 0011 0001
------------------------------------------------------------------------
    Assembler:
    CLC
    MOV al, 0
    ADD we, 0x31 // 0x31 = 0011 0001
    JC etykieta
    JMP etykieta2
    etykieta:
    MOV al, 1
    etykieta2:
    MOV wy, al
    // W skrócie: dodaje liczby do siebie i sprawdzam przeniesienie, jak wystąpiło to liczba jest większa
===========================================================================
Zadanie 3:

    C:
    unsigned char we;
    unsigned short wy;
    wy = we * 24;
    we * 24 = we(32 - 8)
------------------------------------------------------------------
    Assembler:
    MOV ax, 0 // zeruje ax
    MOV al, we // al = we
    SHL ax, 5 // ax = we * 32

    MOV dx, 0 // zeruje dx
    MOV dl, we // dl = we
    ; Chce pomnożyć przez 24 a mnożę przez 32, muszę teraz od ax odjąć we * 8 (pomnożyłem o 8 za dużo)
    SHL dx, 3 // dl = we * 8

    SUB ax, dx // (we * 32) - (we * 8) = we * 24
    MOV wy, ax
===================================================================
Zadanie 4:

    C:
    unsigned short we, wy
    wy = we * 2.625;
    // we * 2.625 = we * (2 + 5/8) = we * (2 + 1/2 + 1/8)
-------------------------------------------------------------------
    Assembler:
    // Zerowanie:
    mov ah, 0
    mov bh, 0
    mov ch, 0
    mov al, we
    shl ax, 4 // we * 16
    mov bl, we
    shl bx, 2 // we * 4
    mov cl, we
    add ax, bx
    add ax, cx // ax = we * 21
    shr ax, 3 // (we * 21) / 8 = we * 21/8 = we * 2 5/8 = we * 2.625
    mov wy, ax
===================================================================
Zadanie 5:

SUMA ZER
-------------------------------------------------------------------
    Assembler:
    mov dl, 0
    mov cl, 0
    petla:
    mov bl, 8
    mov al, we
    shr al, cl
    and al, 0x1
    add dl, al
    add cl, 1
    sub bl, cl
    jz koniec
    jmp petla
    koniec:
    mov bl, 8
    sub bl, dl
    mov suma_zer, bl
====================================================================
SUMA JEDYNEK
--------------------------------------------------------------------
    Assembler:
    mov dl, 0
    mov cl, 0
    petla:
    mov bl, 8
    mov al, we
    shr al, cl
    and al, 0x1
    add dl, al
    add cl, 1
    sub bl, cl
    jz koniec
    jmp petla
    koniec:
    mov suma_jedynek, dl
====================================================================
Zadanie 6:

    C:
    unsigned char wy;
    typedef union{
        unsigned char byte;
        struct{
            unsigned char a:2;
            unsigned char b:3;
            unsigned char c:3;
        }bits;
    }un_x;
    un_x a;
    /////               ////
    //a.bits.c = a.bits.a;//
    //a.bits.b = a.bits.a;//
    ////                ////
---------------------------------------------------------------------
    Assembler:
    mov al, a
    and al, 0x3
    mov bl, al
    shl bl, 2
    mov cl, al
    shl cl, 5
    or cl, bl
    or cl, al
    mov wy, cl
======================================================================
Zadanie 7:

    C:
    unsigned char wy;
    typedef union{
        unsigned char byte;
        struct{
            unsigned char a:1;
            unsigned char b:3;
            unsigned char c:4;
        }bits;
    }un_x;
        un_x a;
        a.byte=0xFF;

        //a.bits.c = a.bits.a * a.bits.b;//

----------------------------------------------------------------------
    Assembler:
    mov al, a
    and al, 0x0F
    mov bl, al
    and bl, 0x1
    jz etykieta1
    mov bl, al
    and bl, 0x0E
    shl bl, 3
    or al, bl
    etykieta1:
    mov wy, al
=======================================================================
Mnożenie:
    MOV AX, 0
    MOV BX, 0
    MOV DX, 0
    MOV AL, a
    MOV BL, b
    P1:
    TEST BL, 0x01
    JZ P2
    ADD DX, AX
    P2:
    SHL AX, 1
    SHR BX, 1
    JNZ P1
    MOV wynik, DX