# coreBugZJ

The Antique Comedians of Malidinesia prefer comedies to tragedies. Unfortunately, most of the ancient plays are tragedies. Therefore the dramatic advisor of ACM has decided to transfigure some tragedies into comedies. Obviously, this work is very hard because the basic sense of the play must be kept intact, although all the things change to their opposites. For example the numbers: if any number appears in the tragedy, it must be converted to its reversed form before being accepted into the comedy play.

Reversed number is a number written in arabic numerals but the order of digits is reversed. The first digit becomes last and vice versa. For example, if the main hero had 1245 strawberries in the tragedy, he has 5421 of them now. Note that all the leading zeros are omitted. That means if the number ends with a zero, the zero is lost by reversing (e.g. 1200 gives 21). Also note that the reversed number never has any trailing zeros.

ACM needs to calculate with reversed numbers. Your task is to add two reversed numbers and output their reversed sum. Of course, the result is not unique because any particular number is a reversed form of several numbers (e.g. 21 could be 12, 120 or 1200 before reversing). Thus we must assume that no zeros were lost by reversing (e.g. assume that the original number was 12).

### Input

The input consists of N cases (equal to about 10000). The first line of the input contains only positive integer N. Then follow the cases. Each case consists of exactly one line with two positive integers separated by space. These are the reversed numbers you are to add.

### Output

For each case, print exactly one line containing only one integer - the reversed sum of two reversed numbers. Omit any leading zeros in the output.

### Example

Sample input:

3
24 1
4358 754
305 794

Sample output:

34
1998
1

1 ; spoj42.s
2
3 %define  L  1024
4
5 section .bss
6         pBuf  : resb  L
7         pBufN : resd 1
8         pBufI : resd 1
9
10 section .text
11         global _start
12
13 _start :
14         mov dword[pBufN], 0x0
15         mov dword[pBufI], 0x0
16         call inInt
17 CASE :
18         test eax, eax
19         jz EXIT
20         dec eax
21         push eax
22
23         call inIntR
24         push eax
25         call inIntR
26         pop ebx
28         call outIntLnR
29
30         pop eax
31         jmp CASE
32 EXIT :
33         mov eax, 0x1
34         mov ebx, 0x0
35         int 0x80
36
37 in eax
38 inChar :
39         mov eax, [pBufI]
40         mov ebx, [pBufN]
41         cmp eax, ebx
42         jne NOEMPTY
43         mov eax, 0x3
44         mov ebx, 0
45         mov ecx, pBuf
46         mov edx, L
47         int 0x80
48         mov [pBufN], eax
49         mov dword[pBufI], 0
50         xor eax, eax
51 NOEMPTY :
52         mov ebx, eax
53         inc ebx
54         mov [pBufI], ebx
56         mov bl, byte[eax]
57         xor eax, eax
58         mov al, bl
59         ret
60
61 in eax
62 inInt :
63         xor eax, eax
64         push eax
65 SKIPSPACE :
66         call inChar
67         cmp al, '0'
68         jb SKIPSPACE
69         cmp al, '9'
70         ja SKIPSPACE
71 INDIGIT :
72         mov ebx, eax
73         pop eax
74         mov ecx, 0xA
75         xor edx, edx
76         mul ecx
77         sub ebx, '0'
79         push eax
80
81         call inChar
82         cmp al, '0'
83         jb INDIGITEND
84         cmp al, '9'
85         ja INDIGITEND
86         jmp INDIGIT
87 INDIGITEND :
88         pop eax
89         ret
90
91 in eax
92 inIntR :
93         xor eax, eax
94         push eax
95         mov eax, 0x1
96         push eax
97 SKIPSPACER :
98         call inChar
99         cmp al, '0'
100         jb SKIPSPACER
101         cmp al, '9'
102         ja SKIPSPACER
103 INDIGITR :
104         sub eax, '0'
105         pop ebx
106         xor edx, edx
107         mul ebx
108         pop ecx
110         push eax
111         mov eax, ebx
112         mov ecx, 0xA
113         xor edx, edx
114         mul ecx
115         push eax
116
117         call inChar
118         cmp al, '0'
119         jb inIntRend
120         cmp al, '9'
121         ja inIntRend
122         jmp INDIGITR
123 inIntRend :
124         pop eax
125         pop eax
126         ret
127
128 out eax
129 outIntLnR :
130         push ebp
131         mov ebp, esp
132         sub esp, 100
133         mov ebx, esp
134 ZEROBEG :
135         test eax, eax
136         jz ZEROEND
137         mov ecx, 0xA
138         xor edx, edx
139         div ecx
141         mov byte[ebx], dl
142         inc ebx
143         jmp ZEROBEG
144 ZEROEND :
145         mov eax, esp
146 ZEROSKIP :
147         mov cl, byte[eax]
148         cmp cl, '0'
149         jnz ZEROSKIPEND
150         inc eax
151         jmp ZEROSKIP
152 ZEROSKIPEND :
153         mov byte[ebx], 0xA
154         inc ebx
155         mov edx, ebx
156         sub edx, eax
157         mov ecx, eax
158         mov eax, 0x4
159         mov ebx, 0x1
160         int 0x80
161
162         mov esp, ebp
163         pop ebp
164         ret
165

posted on 2011-05-18 15:27 coreBugZJ 阅读(496) 评论(0)  编辑 收藏 引用 所属分类: Assemble