求十六进制转为二进制的C语言代码

伟大的玥玥

问题是这样的，我是在linux中先抓包，抓包后的数据是以每2位空格的十六进制存储在自己申请的一段内存中的，如EF 2F 4E，我的问题是如何把这个转换为对应的二进制，如111011110010111110001110，注意十六进制不是我键盘输入的，是读取的数据。这里应该要涉及到移位的问题。（之所以要做这个是要把数据读出来做异或，这样就要先把十六进制转换为相应的二进制）

wssokl

有一个非常简单的算法，直接映射：0 00001 00012 00103 00114 01005 01016 01107 01118 10009 1001A 1010B 1011C 1100D 1101E 1110F 1111每位十六进制数用四位二进制表示 。例如：(1DE)16 =(1 1101 1110)2

lzgw

#include <stdio.h>
int main ()
{
        char s[20], i=-1;//假定20位数的十六进制数字，输入判定就不写了，你自己加
        scanf ("%s",s);
        while (s[++i])
        {
                switch (s[i])
                {
                case 'a':
                        printf ("1010 ");
                        break;
                case 'b':
                        printf ("1011 ");
                        break;
                case 'c':
                        printf ("1100 ");
                        break;
                case 'd':
                        printf ("1101 ");
                        break;
                case 'e':
                        printf ("1110 ");
                        break;
                case 'f':
                        printf ("1111 ");
                        break;
                case '1':
                        printf ("0001 ");
                        break;
                case '2':
                        printf ("0010 ");
                        break;
                case '3':
                        printf ("0011 ");
                        break;
                case '4':
                        printf ("0100 ");
                        break;
                case '5':
                        printf ("0101 ");
                        break;
                case '6':
                        printf ("0110 ");
                        break;
                case '7':
                        printf ("0111 ");
                        break;
                case '8':
                        printf ("1000 ");
                        break;
                case '9':
                        printf ("1001 ");
                        break;
                case '0':
                        printf ("0000 ");
                        break;
                default :
                        exit (0);
                }
        }
        printf("\n");
        return 0;
}

代码农民

1. #include <stdio.h>
   
2. #define N 32
   
3.     /*    如果是32位的话    */
   
4. 
   
5. int
   
6. main()
   
7. {
   
8.     unsigned n, a;              /*  如果需要更长的，可以用unsigned long  */
   
9.     int i;
   
10.    
    
11.     scanf( "%x", &n );        /*  %X, %i也行 , 范围0x0~0xFFFFFFFF(8个F)  */
    
12.     for( i = 0; i < N; ++i )
    
13.     {
    
14.         a = n;
    
15.         printf( "%d",  ( a << i ) >> N - 1 );
    
16.     }
    
17. 
    
18.     printf( "\n" );
    
19.     return 0;
    
20. }

复制代码

四十二

为了这个鱼币我可以给你写，不过你总得把题目完整的说明白啊

张天舒

进制转换问题

伟大的玥玥

四十二 发表于 2016-12-21 00:03
为了这个鱼币我可以给你写，不过你总得把题目完整的说明白啊

问题是这样的，我是在linux中先抓包，抓包后的数据是以每2位空格的十六进制存储在自己申请的一段内存中的，如EF 2F 4E，我的问题是如何把这个转换为对应的二进制，如111011110010111110001110，注意十六进制不是我键盘输入的，是读取的数据。这里应该要涉及到移位的问题。（之所以要做这个是要把数据读出来做异或，这样就要先把十六进制转换为相应的二进制）
我来回答

AsmodeusBaal

1. #include<stdio.h>  
   
2. #include<string.h>  
   
3. #include<stdlib.h>  
   
4. void D_B(int);  
   
5. void D_O(int);  
   
6. void D_X(int);  
   
7. void B_D(int);  
   
8. void B_O(int);  
   
9. void B_X(int);  
   
10. void O_B(int);  
    
11. void O_D(int);  
    
12. void O_X(int);  
    
13. void X_B(char r[],int k);  
    
14. void X_D(char r[],int k);  
    
15. void X_O(char r[],int k);  
    
16. void main()  
    
17. {  
    
18. int i,j,k=0;  
    
19. int q;  
    
20. char r[10];  
    
21. printf("+=============================================================+\n");  
    
22. printf("|            欢  迎  使  用  进  制  转  换  程  序           |\n");  
    
23. printf("+=============================================================+\n");  
    
24. printf("  注 ： 本 版 本 只 做 正 整 数 的 进 制 转 换 ！ ！");  
    
25. do  
    
26. {   
    
27.   q=0;  
    
28.   //fflush(stdin);  
    
29.   printf("\n请选择需要被转换的进制:\n0、退出\n1、二进制\n2、八进制\n3、十进制\n4、十六进制\n");  
    
30.   scanf("%d",&i);  
    
31.   switch (i)  
    
32.   {  
    
33.    case 1: printf("\n请选择转换后的进制:\n0、退出\n1、二进制\n2、八进制\n3、十进制\n4、十六进制\n");  
    
34.      scanf("%d",&j);  
    
35.      switch(j)  
    
36.      {  
    
37.      case 1: printf("\n同进制之间不用转化！\n");  
    
38.        q=1;  
    
39.        break;  
    
40.      case 2: printf("\n请输入您想要转化的数：");  
    
41.        scanf("%d",&k);  
    
42.        B_O(k);  
    
43.        q=1;  
    
44.        break;  
    
45.      case 3: printf("\n请输入您想要转化的数：");  
    
46.        scanf("%d",&k);  
    
47.        B_D(k);  
    
48.        q=1;  
    
49.        break;  
    
50.      case 4: printf("\n请输入您想要转化的数：");  
    
51.        scanf("%d",&k);  
    
52.        B_X(k);  
    
53.        q=1;  
    
54.        break;  
    
55.      case 0:   
    
56.         
    
57.        printf("谢谢使用！！");  
    
58.          
    
59.      }  
    
60.      break;  
    
61.    case 2: printf("\n请选择转换后的进制:\n0、退出\n1、二进制\n2、八进制\n3、十进制\n4、十六进制\n");  
    
62.      scanf("%d",&j);  
    
63.      switch(j)  
    
64.      {  
    
65.      case 2: printf("\n同进制之间不用转化！\n");  
    
66.         q=1;  
    
67.        break;  
    
68.      case 1: printf("\n请输入您想要转化的数：");  
    
69.        scanf("%d",&k);  
    
70.        O_B(k);  
    
71.        q=1;  
    
72.        break;  
    
73.      case 3: printf("\n请输入您想要转化的数：");  
    
74.        scanf("%d",&k);  
    
75.        O_D(k);  
    
76.        q=1;  
    
77.        break;  
    
78.      case 4: printf("\n请输入您想要转化的数：");  
    
79.        scanf("%d",&k);  
    
80.        O_X(k);  
    
81.        q=1;  
    
82.        break;  
    
83.      case 0:   
    
84.        printf("谢谢使用！！");  
    
85.      }   
    
86.      break;  
    
87.    case 3: printf("\n请选择转换后的进制:\n0、退出\n1、二进制\n2、八进制\n3、十进制\n4、十六进制\n");  
    
88.      scanf("%d",&j);  
    
89.      switch(j)  
    
90.      {  
    
91.      case 3: printf("\n同进制之间不用转化！\n");  
    
92.         q=1;  
    
93.         
    
94.        break;  
    
95.      case 1: printf("\n请输入您想要转化的数：");  
    
96.        scanf("%d",&k);  
    
97.        D_B(k);  
    
98.        q=1;  
    
99.        break;  
    
100.      case 2: printf("\n请输入您想要转化的数：");  
     
101.        scanf("%d",&k);  
     
102.        D_O(k);  
     
103.        q=1;  
     
104.        break;  
     
105.      case 4: printf("\n请输入您想要转化的数：");  
     
106.        scanf("%d",&k);  
     
107.        D_X(k);  
     
108.        q=1;  
     
109.        break;  
     
110.      case 0:   
     
111.         
     
112.        printf("谢谢使用！！");  
     
113.      }   
     
114.      break;  
     
115.    case 4: printf("\n请选择转换后的进制:\n0、退出\n1、二进制\n2、八进制\n3、十进制\n4、十六进制\n");  
     
116.      scanf("%d",&j);  
     
117.      switch(j)  
     
118.      {  
     
119.      case 4: printf("\n同进制之间不用转化！\n");  
     
120.         q=1;  
     
121.        break;  
     
122.      case 1: printf("\n请输入您想要转化的数:");  
     
123.         fflush(stdin);  
     
124.         gets(r);  
     
125.         for(k=0;;k++)  
     
126.         {  
     
127.          if(r[k]=='\0')  
     
128.          break;  
     
129.         }  
     
130.          
     
131.        X_B(r,k);  
     
132.        q=1;  
     
133.        break;  
     
134.      case 2: printf("\n请输入您想要转化的数:");  
     
135.        fflush(stdin);  
     
136.         gets(r);  
     
137.         for(k=0;;k++)  
     
138.         {  
     
139.          if(r[k]=='\0')  
     
140.          break;  
     
141.         }  
     
142.          
     
143.        X_O(r,k);  
     
144.        q=1;  
     
145.        break;  
     
146.      case 3: printf("\n请输入您想要转化的数:");  
     
147.        fflush(stdin);  
     
148.         gets(r);  
     
149.         for(k=0;;k++)  
     
150.         {  
     
151.          if(r[k]=='\0')  
     
152.          break;  
     
153.         }  
     
154.        X_D(r,k);  
     
155.        q=1;  
     
156.        break;  
     
157.      case 0:   
     
158.       printf("谢谢使用！！");  
     
159.          
     
160.      }  
     
161.      break;  
     
162.    case 0: printf("\n谢谢使用！\n");  
     
163.       
     
164.   }  
     
165. }while(q==1);  
     
166. }  
     
167. ///////以下为:  二进制转换为十进制,八进制,十六进制.  
     
168. void B_D(int a)  
     
169. {  
     
170. int i,s=0;  
     
171. int result=0;  
     
172. for(i=1;a!=0;i*=2)  
     
173. {  
     
174.   if(a%10>1)  
     
175.   {   
     
176.    s=1;  
     
177.    break;  
     
178.   }  
     
179.   else  
     
180.   {  
     
181.    result+=(a%10)*i;  
     
182.    a=a/10;  
     
183.   }  
     
184. }  
     
185. if(s==1)  
     
186.   printf("您的输入有误！请重新输入\n");  
     
187. else  
     
188. printf("\n转换后的数为：%d\n",result);  
     
189. }  
     
190.    
     
191. void B_O(int a)  
     
192. {  
     
193. int i,j,k,s=0;  
     
194. int p[30];  
     
195. int result=0;  
     
196. for(i=1;a!=0;i*=2)  
     
197. {  
     
198.   if(a%10>1)  
     
199.   {   
     
200.    s=1;  
     
201.    break;  
     
202.   }  
     
203.   else  
     
204.   {  
     
205.    result+=(a%10)*i;  
     
206.    a=a/10;  
     
207.   }  
     
208. }  
     
209. for(j=0;result!=0;j++)  
     
210. {  
     
211.   p[j]=result%8;  
     
212.   result=result/8;  
     
213. }  
     
214. if(s==1)  
     
215.   printf("您的输入有误！请重新输入\n");  
     
216. else   
     
217. {  
     
218.   printf("\n转换后的数为：");  
     
219.   for(k=j-1;k>=0;k--)  
     
220.   {  
     
221.    printf("%d",p[k]);  
     
222.   }  
     
223.   printf("\n");  
     
224. }   
     
225. }  
     
226.    
     
227.   
     
228. void B_X(int a)  
     
229. {  
     
230. int i,j,k,s=0;  
     
231. char p[30];  
     
232. int result=0;  
     
233. for(i=1;a!=0;i*=2)  
     
234. {  
     
235.   if(a%10>1)  
     
236.   {   
     
237.    s=1;  
     
238.    break;  
     
239.   }  
     
240.   else  
     
241.   {  
     
242.    result+=(a%10)*i;  
     
243.    a=a/10;  
     
244.   }  
     
245. }  
     
246. for(j=0;result!=0;j++)  
     
247. {  
     
248.   p[j]=result%16;  
     
249.   result=result/16;  
     
250.   if (p[j]>10)  
     
251.   {  
     
252.    switch(p[j])  
     
253.    {  
     
254.    case 10: p[j]='A';  
     
255.       break;  
     
256.    case 11: p[j]='B';  
     
257.       break;  
     
258.    case 12:    p[j]='C';  
     
259.       break;  
     
260.    case 13:    p[j]='D';  
     
261.       break;  
     
262.    case 14:    p[j]='E';  
     
263.       break;  
     
264.    case 15:    p[j]='F';  
     
265.       break;  
     
266.    }  
     
267.   }  
     
268.   else p[j]+=48;  
     
269. }  
     
270. if(s==1)  
     
271.   printf("您的输入有误！请重新输入\n");  
     
272. else   
     
273. {  
     
274.   printf("\n转换后的数为：");  
     
275.   for(k=j-1;k>=0;k--)  
     
276.   {  
     
277.    printf("%c",p[k]);  
     
278.   }  
     
279.   printf("\n");  
     
280. }  
     
281. }  
     
282. ///////以下为:  八进制转换为二进制,十进制,十六进制.  
     
283. void O_B(int a)  
     
284. {  
     
285. int i,j,k,s=0;  
     
286. int result=0;  
     
287. int p[30];  
     
288. for(i=1;a!=0;i*=8)  
     
289. {if(a%10>7)  
     
290.   {   
     
291.    s=1;  
     
292.    break;  
     
293.   }  
     
294.   else  
     
295.   {  
     
296.    result+=(a%10)*i;  
     
297.    a=a/10;  
     
298.   }  
     
299. }  
     
300. for(j=0;result!=0;j++)  
     
301. {  
     
302.   p[j]=result%2;  
     
303.   result=result/2;  
     
304. }  
     
305. if(s==1)  
     
306.   printf("您的输入有误！请重新输入\n");  
     
307. else   
     
308. {  
     
309.   printf("\n转换后的数为：");  
     
310.   for(k=j-1;k>=0;k--)  
     
311.   {  
     
312.    printf("%d",p[k]);  
     
313.   }  
     
314.   printf("\n");  
     
315. }  
     
316. }  
     
317.    
     
318. void O_D(int a)  
     
319. {  
     
320. int i,s=0;  
     
321. int result=0;  
     
322. for(i=1;a!=0;i*=8)  
     
323. {  
     
324.   if(a%10>7)  
     
325.   {   
     
326.    s=1;  
     
327.    break;  
     
328.   }  
     
329.   else  
     
330.   {  
     
331.    result+=(a%10)*i;  
     
332.    a=a/10;  
     
333.   }  
     
334. }  
     
335. if(s==1)  
     
336.   printf("您的输入有误！请重新输入\n");  
     
337. else   
     
338. {  
     
339.   printf("\n转换后的数为：%d\n",result);  
     
340. }  
     
341. }  
     
342.    
     
343. void O_X(int a)  
     
344. {  
     
345. int i,j,k,s=0;  
     
346. char p[30];  
     
347. int result=0;  
     
348. for(i=1;a!=0;i*=8)  
     
349. {  
     
350.   if(a%10>7)  
     
351.   {   
     
352.    s=1;  
     
353.    break;  
     
354.   }  
     
355.   else  
     
356.   {  
     
357.    result+=(a%10)*i;  
     
358.    a=a/10;  
     
359.   }  
     
360. }  
     
361. for(j=0;result!=0;j++)  
     
362. {  
     
363.   p[j]=result%16;  
     
364.   result=result/16;  
     
365.   if(p[j]<10)  
     
366.    p[j]+=48;  
     
367.   else  
     
368.   {  
     
369.    switch(p[j])  
     
370.    {  
     
371.    case 10: p[j]='A';  
     
372.       break;  
     
373.    case 11: p[j]='B';  
     
374.       break;  
     
375.    case 12:    p[j]='C';  
     
376.       break;  
     
377.    case 13:    p[j]='D';  
     
378.       break;  
     
379.    case 14:    p[j]='E';  
     
380.       break;  
     
381.    case 15:    p[j]='F';  
     
382.       break;  
     
383.    }  
     
384.   }  
     
385. }  
     
386. if(s==1)  
     
387.   printf("您的输入有误！请重新输入\n");  
     
388. else   
     
389. {  
     
390.   printf("\n转换后的数为：");  
     
391.   for(k=j-1;k>=0;k--)  
     
392.   {  
     
393.    printf("%c",p[k]);  
     
394.   }  
     
395.   printf("\n");  
     
396. }  
     
397. }  
     
398. ///////以下为:  十六进制转换为十进制,二进制,八进制.  
     
399. void X_D(char a[],int k)  
     
400. {  
     
401. int i,j,s=0;  
     
402. int result=0;  
     
403. int b[50];  
     
404. for(i=0;i<k;i++)  
     
405. {  
     
406.   if(a[i]<='9'&&a[i]>='1')  
     
407.   { b[i]=a[i]-48;  
     
408.       
     
409.   }  
     
410.   else  
     
411.   {  
     
412.    switch(a[i])  
     
413.    {  
     
414.    case 'A': b[i]=10;  
     
415.       break;  
     
416.    case 'B': b[i]=11;  
     
417.       break;  
     
418.    case 'C':   b[i]=12;  
     
419.       break;  
     
420.    case 'D':   b[i]=13;  
     
421.       break;  
     
422.    case 'E':   b[i]=14;  
     
423.       break;  
     
424.    case 'F':   b[i]=15;  
     
425.       break;  
     
426.    case 'a': b[i]=10;  
     
427.       break;  
     
428.    case 'b': b[i]=11;  
     
429.       break;  
     
430.    case 'c':   b[i]=12;  
     
431.       break;  
     
432.    case 'd':   b[i]=13;  
     
433.       break;  
     
434.    case 'e':   b[i]=14;  
     
435.       break;  
     
436.    case 'f':   b[i]=15;  
     
437.       break;  
     
438.    default:  s=1;  
     
439.         
     
440.    }  
     
441.      
     
442.   }  
     
443. }  
     
444. for(i=1,j=k-1;j>=0;j--,i*=16)  
     
445. {  
     
446.   result+=b[j]*i;  
     
447. }  
     
448. if(s==1)  
     
449.   printf("您的输入有误！请重新输入\n");  
     
450. else   
     
451. {  
     
452.   printf("\n转换后的数为：%d",result);  
     
453. }  
     
454. }  
     
455.    
     
456.   
     
457. void X_B(char a[],int k)  
     
458. {  
     
459. int i,j,s=0;  
     
460. int result=0;  
     
461. int b[50];  
     
462. int p[30];  
     
463. for(i=0;i<k;i++)  
     
464. {  
     
465.   if(a[i]<='9'&&a[i]>='1')  
     
466.    b[i]=a[i]-48;  
     
467.   else  
     
468.   {  
     
469.    switch(a[i])  
     
470.    {  
     
471.    case 'A': b[i]=10;  
     
472.       break;  
     
473.    case 'B': b[i]=11;  
     
474.       break;  
     
475.    case 'C':   b[i]=12;  
     
476.       break;  
     
477.    case 'D':   b[i]=13;  
     
478.       break;  
     
479.    case 'E':   b[i]=14;  
     
480.       break;  
     
481.    case 'F':   b[i]=15;  
     
482.       break;  
     
483.    case 'a': b[i]=10;  
     
484.       break;  
     
485.    case 'b': b[i]=11;  
     
486.       break;  
     
487.    case 'c':   b[i]=12;  
     
488.       break;  
     
489.    case 'd':   b[i]=13;  
     
490.       break;  
     
491.    case 'e':   b[i]=14;  
     
492.       break;  
     
493.    case 'f':   b[i]=15;  
     
494.       break;  
     
495.    default: s=1;  
     
496.         
     
497.    }  
     
498.   }  
     
499. }  
     
500. for(j=k-1,i=1;j>=0;j--,i*=16)  
     
501. {  
     
502.   result+=b[j]*i;  
     
503. }  
     
504.   for(j=0;result!=0;j++)  
     
505. {  
     
506.   p[j]=result%2;  
     
507.   result=result/2;  
     
508. }  
     
509. if(s==1)  
     
510.   printf("您的输入有误！请重新输入\n");  
     
511. else   
     
512. {  
     
513.   printf("\n转换后的数为：");  
     
514.   for(k=j-1;k>=0;k--)  
     
515.   {  
     
516.    printf("%d",p[k]);  
     
517.   }  
     
518.   printf("\n");  
     
519. }  
     
520. }  
     
521.    
     
522. void X_O(char a[],int k)  
     
523. {  
     
524. int i,j,s=0;  
     
525. int result=0;  
     
526. int b[30];  
     
527. int p[30];  
     
528. for(i=0;i<k;i++)  
     
529. {  
     
530.   if(a[i]<='9'&&a[i]>='1')  
     
531.    b[i]=a[i]-48;  
     
532.   else  
     
533.   {  
     
534.    switch(a[i])  
     
535.    {  
     
536.    case 'A': b[i]=10;  
     
537.       break;  
     
538.    case 'B': b[i]=11;  
     
539.       break;  
     
540.    case 'C':   b[i]=12;  
     
541.       break;  
     
542.    case 'D':   b[i]=13;  
     
543.       break;  
     
544.    case 'E':   b[i]=14;  
     
545.       break;  
     
546.    case 'F':   b[i]=15;  
     
547.       break;  
     
548.    case 'a': b[i]=10;  
     
549.       break;  
     
550.    case 'b': b[i]=11;  
     
551.       break;  
     
552.    case 'c':   b[i]=12;  
     
553.       break;  
     
554.    case 'd':   b[i]=13;  
     
555.       break;  
     
556.    case 'e':   b[i]=14;  
     
557.       break;  
     
558.    case 'f':   b[i]=15;  
     
559.       break;  
     
560.    default: s=1;  
     
561.    }  
     
562.   }  
     
563. }  
     
564. for(j=k-1,i=1;j>=0;j--,i*=16)  
     
565. {  
     
566.   result+=b[j]*i;  
     
567. }  
     
568.   for(j=0;result!=0;j++)  
     
569. {  
     
570.   p[j]=result%8;  
     
571.   result=result/8;  
     
572. }  
     
573. if(s==1)  
     
574.   printf("您的输入有误！请重新输入\n");  
     
575. else   
     
576. {  
     
577.   printf("\n转换后的数为：");  
     
578.   for(k=j-1;k>=0;k--)  
     
579.   {  
     
580.    printf("%d",p[k]);  
     
581.   }  
     
582.   printf("\n");  
     
583. }  
     
584. }  
     
585. ///////以下为:  十进制转换为二进制,八进制,十六进制.  
     
586. void D_B(int a)  
     
587. {  
     
588. int j,k;  
     
589. int p[30];  
     
590. for(j=0;a!=0;j++)  
     
591. {  
     
592.   p[j]=a%2;  
     
593.   a=a/2;  
     
594. }  
     
595. printf("\n转换后的数为：");  
     
596. for(k=j-1;k>=0;k--)  
     
597. {  
     
598.   printf("%d",p[k]);  
     
599. }  
     
600. printf("\n");  
     
601. }  
     
602.    
     
603. void D_O(int a)  
     
604. {  
     
605. int j,k;  
     
606. int p[30];  
     
607. for(j=0;a!=0;j++)  
     
608. {  
     
609.   p[j]=a%8;  
     
610.   a=a/8;  
     
611. }  
     
612. printf("\n转换后的数为：");  
     
613. for(k=j-1;k>=0;k--)  
     
614. {  
     
615.   printf("%d",p[k]);  
     
616. }  
     
617. printf("\n");  
     
618. }  
     
619.   
     
620. void D_X(int a)  
     
621. {  
     
622. int j,k;  
     
623. int p[30];  
     
624. for(j=0;a!=0;j++)  
     
625. {  
     
626.   p[j]=a%16;  
     
627.   a=a/16;  
     
628.   if(p[j]<10)  
     
629.    p[j]+=48;  
     
630.   else  
     
631.   {  
     
632.    switch(p[j])  
     
633.    {  
     
634.    case 10: p[j]='A';  
     
635.       break;  
     
636.    case 11: p[j]='B';  
     
637.       break;  
     
638.    case 12:    p[j]='C';  
     
639.       break;  
     
640.    case 13:    p[j]='D';  
     
641.       break;  
     
642.    case 14:    p[j]='E';  
     
643.       break;  
     
644.    case 15:    p[j]='F';  
     
645.       break;  
     
646.    }  
     
647.   }  
     
648. }  
     
649. printf("\n转换后的数为：");  
     
650. for(k=j-1;k>=0;k--)  
     
651. {  
     
652.   printf("%c",p[k]);  
     
653. }  
     
654. printf("\n");  
     
655. }  

复制代码

这是C++的代码我从CSDN上转载的

鱼油小白

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int a;
    char b[100];
    scanf("%d",&a);
    itoa(a,b,2);
    printf("%s",b);
}