daily pastebin goal
80%
SHARE
TWEET

Untitled

a guest Dec 17th, 2018 72 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. Zadanie 1 - Zamiana kolejności bitów w bajcie
  2. unsigned char a = 0x80, b = 0x00;
  3. __asm {
  4.     mov al, a;
  5.     mov bl, b;
  6.     mov cl, 0xFF;
  7.  
  8. repeat:
  9.     mov ah, al;
  10.     and ah, 0x01;
  11.     shl bl, 1;
  12.     or bl, ah;
  13.     shr al, 1;
  14.     shr cl, 1;
  15.     jnz repeat;
  16.  
  17.     mov b, bl;
  18. };
  19. printf("0x%02X po odwroceniu to 0x%02X", a, b);
  20.  
  21. Zadanie 2 - parzystość liczby jedynek w bajcie
  22. unsigned char a = 0x03, b;
  23. __asm {
  24.     mov al, a;
  25.     mov bl, 0x01;
  26.  
  27.     mov ah, al;
  28.     and ah, 0x01;
  29.     add bl, ah;
  30.     shr al, 1;
  31.  
  32.     mov ah, al;
  33.     and ah, 0x01;
  34.     add bl, ah;
  35.     shr al, 1;
  36.  
  37.     mov ah, al;
  38.     and ah, 0x01;
  39.     add bl, ah;
  40.     shr al, 1;
  41.  
  42.     mov ah, al;
  43.     and ah, 0x01;
  44.     add bl, ah;
  45.     shr al, 1;
  46.  
  47.     mov ah, al;
  48.     and ah, 0x01;
  49.     add bl, ah;
  50.     shr al, 1;
  51.  
  52.     mov ah, al;
  53.     and ah, 0x01;
  54.     add bl, ah;
  55.     shr al, 1;
  56.  
  57.     mov ah, al;
  58.     and ah, 0x01;
  59.     add bl, ah;
  60.     shr al, 1;
  61.  
  62.     mov ah, al;
  63.     and ah, 0x01;
  64.     add bl, ah;
  65.  
  66.     and bl, 0x01;
  67.     mov b, bl;
  68. };
  69. printf("Ilosc jedynek w 0x%02X parzysta - %d", a, b);
  70.  
  71. Zadanie 3 - liczba zer w bajcie
  72. unsigned char a = 0xFF, licz = 0;
  73. _asm {
  74.     mov al, a
  75.     mov cl, 0
  76.  
  77.     mov ah, al
  78.     and ah, 0x01
  79.     add cl, ah
  80.     shr al, 1
  81.  
  82.     mov ah, al
  83.     and ah, 0x01
  84.     add cl, ah
  85.     shr al, 1
  86.  
  87.     mov ah, al
  88.     and ah, 0x01
  89.     add cl, ah
  90.     shr al, 1
  91.  
  92.     mov ah, al
  93.     and ah, 0x01
  94.     add cl, ah
  95.     shr al, 1
  96.  
  97.     mov ah, al
  98.     and ah, 0x01
  99.     add cl, ah
  100.     shr al, 1
  101.  
  102.     mov ah, al
  103.     and ah, 0x01
  104.     add cl, ah
  105.     shr al, 1
  106.  
  107.     mov ah, al
  108.     and ah, 0x01
  109.     add cl, ah
  110.     shr al, 1
  111.  
  112.     mov ah, al
  113.     and ah, 0x01
  114.     add cl, ah
  115.     shr al, 1
  116.  
  117.     mov licz, 8
  118.     sub licz, cl
  119. }
  120. printf("Ilosc zer w 0x%02X - %d", a, licz);
  121.  
  122. Zadanie 4 - if (wejscie == 0x32) to wyjscie = 0, else wyjscie = 1
  123. unsigned char a = 0x32, b;
  124. __asm {
  125.     mov bl, 0x00;
  126.     mov al, a;
  127.     0xCE to 0x32 z minusem
  128.         add al, 0xCE;
  129.     jz skok
  130.         add bl, 0x01;
  131. skok:
  132.     mov b, bl;
  133. };
  134. printf("wyjscie = %d", b);
  135.  
  136. Zadanie 5 - if wejscie  < z flagą C
  137.     unsigned char a = 0xC0, y;
  138. __asm {
  139.     mov al, a
  140.     add al, 0x40
  141.     jc els
  142.     mov y, 0
  143.     jmp koniec
  144.     els :
  145.     mov y, 1
  146.         koniec :
  147. };
  148. printf("wyjscie = %d", y);
  149.  
  150. Zadanie 6 - wejscie 8 - bit, wyjscie 16 - bit.y = a * 20
  151. unsigned char a = 0x02;
  152. short int wynik;
  153. __asm {
  154.     mov al, a;
  155.     mov ah, 0x00;
  156.  
  157.     mov dx, ax;
  158.     shl dx, 5;
  159.     mov bx, dx;
  160.  
  161.     mov dx, ax;
  162.     shl dx, 3;
  163.     sub bx, dx;
  164.  
  165.     mov dx, ax;
  166.     shl dx, 2;
  167.     sub bx, dx;
  168.  
  169.     mov wynik, bx;
  170. };
  171. printf("%d * 20 = %d", a, wynik);
  172.  
  173. Zadanie 7 - a i b 8 - bit, y 16 - bit.y = a*b
  174. unsigned char a = 5, b = 6;
  175. short int y = 0;
  176. _asm {
  177.     mov ah, 0
  178.     mov al, a
  179.     mov bl, b
  180.     mov cx, y
  181.     start :
  182.     test bl, 0x01
  183.         jz nie
  184.         add cx, ax
  185.         nie :
  186.     shr bl, 1
  187.         shl ax, 1
  188.         jnz start
  189.         mov y, cx
  190. }
  191. printf("%d*%d=%d", a, b, y);
  192.  
  193. Zadanie 8 - y = a * 1.125.a jest 16 - bit
  194. short int a = 1000, wynik = 0;
  195. __asm {
  196.     mov ax, a;
  197.     mov bx, ax;
  198.     shr bx, 3;
  199.     add ax, bx;
  200.     mov wynik, ax;
  201. };
  202. printf("%d * 1.125 = %d", a, wynik);
  203.  
  204. Zadanie 9 - unie c = a, b = a
  205. typedef union {
  206.     unsigned char BYTE;
  207.     struct {
  208.         unsigned char a : 2;
  209.         unsigned char b : 3;
  210.         unsigned char c : 3;
  211.     }bits;
  212. }un_X;
  213. un_X x;
  214. x.BYTE = 3;
  215. __asm {
  216.     mov al, x.BYTE
  217.     and al, 0x03
  218.     mov bl, al
  219.     shl al, 2
  220.     or bl, al
  221.     shl al, 3
  222.     or bl, al
  223.     mov x.BYTE, bl
  224. }
  225. printf("%X  \n", x.BYTE);
  226. printf("%X %X %X", x.bits.a, x.bits.b, x.bits.c);
  227.  
  228. Zadanie 10 - unie c = a * b
  229. typedef union {
  230.     unsigned char BYTE;
  231.     struct {
  232.         unsigned char a : 1;
  233.         unsigned char b : 3;
  234.         unsigned char c : 4;
  235.     }bits;
  236. }un_Y;
  237. un_Y y;
  238. y.bits.a = 0;
  239. y.bits.b = 6;
  240. __asm {
  241.     mov al, y.BYTE
  242.     mov bl, al
  243.     mov cl, 0
  244.     and bl, 0x0E
  245.     and al, 0x01
  246.     JZ ELSE10
  247.     mov cl, bl
  248.     shl cl, 3
  249.     ELSE10:
  250.     or cl, al
  251.         or cl, bl
  252.         mov y.BYTE, cl
  253. }
  254. printf("%X  \n", y.BYTE);
  255. printf("%X %X %X", y.bits.a, y.bits.b, y.bits.c);
  256.  
  257. Zadanie 11 - PUSH i POP inaczej
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top