• API
• FAQ
• Tools
• Archive
SHARE
TWEET

# Untitled

a guest Dec 17th, 2018 73 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;
30.     shr al, 1;
31.
32.     mov ah, al;
33.     and ah, 0x01;
35.     shr al, 1;
36.
37.     mov ah, al;
38.     and ah, 0x01;
40.     shr al, 1;
41.
42.     mov ah, al;
43.     and ah, 0x01;
45.     shr al, 1;
46.
47.     mov ah, al;
48.     and ah, 0x01;
50.     shr al, 1;
51.
52.     mov ah, al;
53.     and ah, 0x01;
55.     shr al, 1;
56.
57.     mov ah, al;
58.     and ah, 0x01;
60.     shr al, 1;
61.
62.     mov ah, al;
63.     and ah, 0x01;
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
80.     shr al, 1
81.
82.     mov ah, al
83.     and ah, 0x01
85.     shr al, 1
86.
87.     mov ah, al
88.     and ah, 0x01
90.     shr al, 1
91.
92.     mov ah, al
93.     and ah, 0x01
95.     shr al, 1
96.
97.     mov ah, al
98.     and ah, 0x01
100.     shr al, 1
101.
102.     mov ah, al
103.     and ah, 0x01
105.     shr al, 1
106.
107.     mov ah, al
108.     and ah, 0x01
110.     shr al, 1
111.
112.     mov ah, al
113.     and ah, 0x01
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
129.     jz skok
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
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
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;
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.

Top