Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | | |
2 | | decbin.sa 3.3 12/19/90 | |
3 | | | |
4 | | Description: Converts normalized packed bcd value pointed to by | |
5 | | register A6 to extended-precision value in FP0. | |
6 | | | |
7 | | Input: Normalized packed bcd value in ETEMP(a6). | |
8 | | | |
9 | | Output: Exact floating-point representation of the packed bcd value. | |
10 | | | |
11 | | Saves and Modifies: D2-D5 | |
12 | | | |
13 | | Speed: The program decbin takes ??? cycles to execute. | |
14 | | | |
15 | | Object Size: | |
16 | | | |
17 | | External Reference(s): None. | |
18 | | | |
19 | | Algorithm: | |
20 | | Expected is a normal bcd (i.e. non-exceptional; all inf, zero, | |
21 | | and NaN operands are dispatched without entering this routine) | |
22 | | value in 68881/882 format at location ETEMP(A6). | |
23 | | | |
24 | | A1. Convert the bcd exponent to binary by successive adds and muls. | |
25 | | Set the sign according to SE. Subtract 16 to compensate | |
26 | | for the mantissa which is to be interpreted as 17 integer | |
27 | | digits, rather than 1 integer and 16 fraction digits. | |
28 | | Note: this operation can never overflow. | |
29 | | | |
30 | | A2. Convert the bcd mantissa to binary by successive | |
31 | | adds and muls in FP0. Set the sign according to SM. | |
32 | | The mantissa digits will be converted with the decimal point | |
33 | | assumed following the least-significant digit. | |
34 | | Note: this operation can never overflow. | |
35 | | | |
36 | | A3. Count the number of leading/trailing zeros in the | |
37 | | bcd string. If SE is positive, count the leading zeros; | |
38 | | if negative, count the trailing zeros. Set the adjusted | |
39 | | exponent equal to the exponent from A1 and the zero count | |
40 | | added if SM = 1 and subtracted if SM = 0. Scale the | |
41 | | mantissa the equivalent of forcing in the bcd value: | |
42 | | | |
43 | | SM = 0 a non-zero digit in the integer position | |
44 | | SM = 1 a non-zero digit in Mant0, lsd of the fraction | |
45 | | | |
46 | | this will insure that any value, regardless of its | |
47 | | representation (ex. 0.1E2, 1E1, 10E0, 100E-1), is converted | |
48 | | consistently. | |
49 | | | |
50 | | A4. Calculate the factor 10^exp in FP1 using a table of | |
51 | | 10^(2^n) values. To reduce the error in forming factors | |
52 | | greater than 10^27, a directed rounding scheme is used with | |
53 | | tables rounded to RN, RM, and RP, according to the table | |
54 | | in the comments of the pwrten section. | |
55 | | | |
56 | | A5. Form the final binary number by scaling the mantissa by | |
57 | | the exponent factor. This is done by multiplying the | |
58 | | mantissa in FP0 by the factor in FP1 if the adjusted | |
59 | | exponent sign is positive, and dividing FP0 by FP1 if | |
60 | | it is negative. | |
61 | | | |
62 | | Clean up and return. Check if the final mul or div resulted | |
63 | | in an inex2 exception. If so, set inex1 in the fpsr and | |
64 | | check if the inex1 exception is enabled. If so, set d7 upper | |
65 | | word to $0100. This will signal unimp.sa that an enabled inex1 | |
66 | | exception occurred. Unimp will fix the stack. | |
67 | | | |
68 | ||
69 | | Copyright (C) Motorola, Inc. 1990 | |
70 | | All Rights Reserved | |
71 | | | |
e00d82d0 MW |
72 | | For details on the license for this file, please see the |
73 | | file, README, in this same directory. | |
1da177e4 LT |
74 | |
75 | |DECBIN idnt 2,1 | Motorola 040 Floating Point Software Package | |
76 | ||
77 | |section 8 | |
78 | ||
79 | #include "fpsp.h" | |
80 | ||
81 | | | |
82 | | PTENRN, PTENRM, and PTENRP are arrays of powers of 10 rounded | |
83 | | to nearest, minus, and plus, respectively. The tables include | |
84 | | 10**{1,2,4,8,16,32,64,128,256,512,1024,2048,4096}. No rounding | |
85 | | is required until the power is greater than 27, however, all | |
86 | | tables include the first 5 for ease of indexing. | |
87 | | | |
88 | |xref PTENRN | |
89 | |xref PTENRM | |
90 | |xref PTENRP | |
91 | ||
92 | RTABLE: .byte 0,0,0,0 | |
93 | .byte 2,3,2,3 | |
94 | .byte 2,3,3,2 | |
95 | .byte 3,2,2,3 | |
96 | ||
97 | .global decbin | |
98 | .global calc_e | |
99 | .global pwrten | |
100 | .global calc_m | |
101 | .global norm | |
102 | .global ap_st_z | |
103 | .global ap_st_n | |
104 | | | |
105 | .set FNIBS,7 | |
106 | .set FSTRT,0 | |
107 | | | |
108 | .set ESTRT,4 | |
109 | .set EDIGITS,2 | | |
110 | | | |
111 | | Constants in single precision | |
112 | FZERO: .long 0x00000000 | |
113 | FONE: .long 0x3F800000 | |
114 | FTEN: .long 0x41200000 | |
115 | ||
116 | .set TEN,10 | |
117 | ||
118 | | | |
119 | decbin: | |
120 | | fmovel #0,FPCR ;clr real fpcr | |
121 | moveml %d2-%d5,-(%a7) | |
122 | | | |
123 | | Calculate exponent: | |
124 | | 1. Copy bcd value in memory for use as a working copy. | |
125 | | 2. Calculate absolute value of exponent in d1 by mul and add. | |
126 | | 3. Correct for exponent sign. | |
127 | | 4. Subtract 16 to compensate for interpreting the mant as all integer digits. | |
128 | | (i.e., all digits assumed left of the decimal point.) | |
129 | | | |
130 | | Register usage: | |
131 | | | |
132 | | calc_e: | |
133 | | (*) d0: temp digit storage | |
134 | | (*) d1: accumulator for binary exponent | |
135 | | (*) d2: digit count | |
136 | | (*) d3: offset pointer | |
137 | | ( ) d4: first word of bcd | |
138 | | ( ) a0: pointer to working bcd value | |
139 | | ( ) a6: pointer to original bcd value | |
140 | | (*) FP_SCR1: working copy of original bcd value | |
141 | | (*) L_SCR1: copy of original exponent word | |
142 | | | |
143 | calc_e: | |
144 | movel #EDIGITS,%d2 |# of nibbles (digits) in fraction part | |
145 | moveql #ESTRT,%d3 |counter to pick up digits | |
146 | leal FP_SCR1(%a6),%a0 |load tmp bcd storage address | |
147 | movel ETEMP(%a6),(%a0) |save input bcd value | |
148 | movel ETEMP_HI(%a6),4(%a0) |save words 2 and 3 | |
149 | movel ETEMP_LO(%a6),8(%a0) |and work with these | |
150 | movel (%a0),%d4 |get first word of bcd | |
151 | clrl %d1 |zero d1 for accumulator | |
152 | e_gd: | |
153 | mulul #TEN,%d1 |mul partial product by one digit place | |
154 | bfextu %d4{%d3:#4},%d0 |get the digit and zero extend into d0 | |
155 | addl %d0,%d1 |d1 = d1 + d0 | |
156 | addqb #4,%d3 |advance d3 to the next digit | |
157 | dbf %d2,e_gd |if we have used all 3 digits, exit loop | |
158 | btst #30,%d4 |get SE | |
159 | beqs e_pos |don't negate if pos | |
160 | negl %d1 |negate before subtracting | |
161 | e_pos: | |
162 | subl #16,%d1 |sub to compensate for shift of mant | |
163 | bges e_save |if still pos, do not neg | |
164 | negl %d1 |now negative, make pos and set SE | |
165 | orl #0x40000000,%d4 |set SE in d4, | |
166 | orl #0x40000000,(%a0) |and in working bcd | |
167 | e_save: | |
168 | movel %d1,L_SCR1(%a6) |save exp in memory | |
169 | | | |
170 | | | |
171 | | Calculate mantissa: | |
172 | | 1. Calculate absolute value of mantissa in fp0 by mul and add. | |
173 | | 2. Correct for mantissa sign. | |
174 | | (i.e., all digits assumed left of the decimal point.) | |
175 | | | |
176 | | Register usage: | |
177 | | | |
178 | | calc_m: | |
179 | | (*) d0: temp digit storage | |
180 | | (*) d1: lword counter | |
181 | | (*) d2: digit count | |
182 | | (*) d3: offset pointer | |
183 | | ( ) d4: words 2 and 3 of bcd | |
184 | | ( ) a0: pointer to working bcd value | |
185 | | ( ) a6: pointer to original bcd value | |
186 | | (*) fp0: mantissa accumulator | |
187 | | ( ) FP_SCR1: working copy of original bcd value | |
188 | | ( ) L_SCR1: copy of original exponent word | |
189 | | | |
190 | calc_m: | |
191 | moveql #1,%d1 |word counter, init to 1 | |
192 | fmoves FZERO,%fp0 |accumulator | |
193 | | | |
194 | | | |
195 | | Since the packed number has a long word between the first & second parts, | |
196 | | get the integer digit then skip down & get the rest of the | |
197 | | mantissa. We will unroll the loop once. | |
198 | | | |
199 | bfextu (%a0){#28:#4},%d0 |integer part is ls digit in long word | |
200 | faddb %d0,%fp0 |add digit to sum in fp0 | |
201 | | | |
202 | | | |
203 | | Get the rest of the mantissa. | |
204 | | | |
205 | loadlw: | |
206 | movel (%a0,%d1.L*4),%d4 |load mantissa longword into d4 | |
207 | moveql #FSTRT,%d3 |counter to pick up digits | |
208 | moveql #FNIBS,%d2 |reset number of digits per a0 ptr | |
209 | md2b: | |
210 | fmuls FTEN,%fp0 |fp0 = fp0 * 10 | |
211 | bfextu %d4{%d3:#4},%d0 |get the digit and zero extend | |
212 | faddb %d0,%fp0 |fp0 = fp0 + digit | |
213 | | | |
214 | | | |
215 | | If all the digits (8) in that long word have been converted (d2=0), | |
216 | | then inc d1 (=2) to point to the next long word and reset d3 to 0 | |
217 | | to initialize the digit offset, and set d2 to 7 for the digit count; | |
218 | | else continue with this long word. | |
219 | | | |
220 | addqb #4,%d3 |advance d3 to the next digit | |
221 | dbf %d2,md2b |check for last digit in this lw | |
222 | nextlw: | |
223 | addql #1,%d1 |inc lw pointer in mantissa | |
224 | cmpl #2,%d1 |test for last lw | |
225 | ble loadlw |if not, get last one | |
226 | ||
227 | | | |
228 | | Check the sign of the mant and make the value in fp0 the same sign. | |
229 | | | |
230 | m_sign: | |
231 | btst #31,(%a0) |test sign of the mantissa | |
232 | beq ap_st_z |if clear, go to append/strip zeros | |
233 | fnegx %fp0 |if set, negate fp0 | |
234 | ||
235 | | | |
236 | | Append/strip zeros: | |
237 | | | |
238 | | For adjusted exponents which have an absolute value greater than 27*, | |
239 | | this routine calculates the amount needed to normalize the mantissa | |
240 | | for the adjusted exponent. That number is subtracted from the exp | |
241 | | if the exp was positive, and added if it was negative. The purpose | |
242 | | of this is to reduce the value of the exponent and the possibility | |
243 | | of error in calculation of pwrten. | |
244 | | | |
245 | | 1. Branch on the sign of the adjusted exponent. | |
246 | | 2p.(positive exp) | |
247 | | 2. Check M16 and the digits in lwords 2 and 3 in descending order. | |
248 | | 3. Add one for each zero encountered until a non-zero digit. | |
249 | | 4. Subtract the count from the exp. | |
250 | | 5. Check if the exp has crossed zero in #3 above; make the exp abs | |
251 | | and set SE. | |
252 | | 6. Multiply the mantissa by 10**count. | |
253 | | 2n.(negative exp) | |
254 | | 2. Check the digits in lwords 3 and 2 in descending order. | |
255 | | 3. Add one for each zero encountered until a non-zero digit. | |
256 | | 4. Add the count to the exp. | |
257 | | 5. Check if the exp has crossed zero in #3 above; clear SE. | |
258 | | 6. Divide the mantissa by 10**count. | |
259 | | | |
260 | | *Why 27? If the adjusted exponent is within -28 < expA < 28, than | |
261 | | any adjustment due to append/strip zeros will drive the resultant | |
262 | | exponent towards zero. Since all pwrten constants with a power | |
263 | | of 27 or less are exact, there is no need to use this routine to | |
264 | | attempt to lessen the resultant exponent. | |
265 | | | |
266 | | Register usage: | |
267 | | | |
268 | | ap_st_z: | |
269 | | (*) d0: temp digit storage | |
270 | | (*) d1: zero count | |
271 | | (*) d2: digit count | |
272 | | (*) d3: offset pointer | |
273 | | ( ) d4: first word of bcd | |
274 | | (*) d5: lword counter | |
275 | | ( ) a0: pointer to working bcd value | |
276 | | ( ) FP_SCR1: working copy of original bcd value | |
277 | | ( ) L_SCR1: copy of original exponent word | |
278 | | | |
279 | | | |
280 | | First check the absolute value of the exponent to see if this | |
281 | | routine is necessary. If so, then check the sign of the exponent | |
282 | | and do append (+) or strip (-) zeros accordingly. | |
283 | | This section handles a positive adjusted exponent. | |
284 | | | |
285 | ap_st_z: | |
286 | movel L_SCR1(%a6),%d1 |load expA for range test | |
287 | cmpl #27,%d1 |test is with 27 | |
288 | ble pwrten |if abs(expA) <28, skip ap/st zeros | |
289 | btst #30,(%a0) |check sign of exp | |
290 | bne ap_st_n |if neg, go to neg side | |
291 | clrl %d1 |zero count reg | |
292 | movel (%a0),%d4 |load lword 1 to d4 | |
293 | bfextu %d4{#28:#4},%d0 |get M16 in d0 | |
294 | bnes ap_p_fx |if M16 is non-zero, go fix exp | |
295 | addql #1,%d1 |inc zero count | |
296 | moveql #1,%d5 |init lword counter | |
297 | movel (%a0,%d5.L*4),%d4 |get lword 2 to d4 | |
298 | bnes ap_p_cl |if lw 2 is zero, skip it | |
299 | addql #8,%d1 |and inc count by 8 | |
300 | addql #1,%d5 |inc lword counter | |
301 | movel (%a0,%d5.L*4),%d4 |get lword 3 to d4 | |
302 | ap_p_cl: | |
303 | clrl %d3 |init offset reg | |
304 | moveql #7,%d2 |init digit counter | |
305 | ap_p_gd: | |
306 | bfextu %d4{%d3:#4},%d0 |get digit | |
307 | bnes ap_p_fx |if non-zero, go to fix exp | |
308 | addql #4,%d3 |point to next digit | |
309 | addql #1,%d1 |inc digit counter | |
310 | dbf %d2,ap_p_gd |get next digit | |
311 | ap_p_fx: | |
312 | movel %d1,%d0 |copy counter to d2 | |
313 | movel L_SCR1(%a6),%d1 |get adjusted exp from memory | |
314 | subl %d0,%d1 |subtract count from exp | |
315 | bges ap_p_fm |if still pos, go to pwrten | |
316 | negl %d1 |now its neg; get abs | |
317 | movel (%a0),%d4 |load lword 1 to d4 | |
318 | orl #0x40000000,%d4 | and set SE in d4 | |
319 | orl #0x40000000,(%a0) | and in memory | |
320 | | | |
321 | | Calculate the mantissa multiplier to compensate for the striping of | |
322 | | zeros from the mantissa. | |
323 | | | |
324 | ap_p_fm: | |
325 | movel #PTENRN,%a1 |get address of power-of-ten table | |
326 | clrl %d3 |init table index | |
327 | fmoves FONE,%fp1 |init fp1 to 1 | |
328 | moveql #3,%d2 |init d2 to count bits in counter | |
329 | ap_p_el: | |
330 | asrl #1,%d0 |shift lsb into carry | |
331 | bccs ap_p_en |if 1, mul fp1 by pwrten factor | |
332 | fmulx (%a1,%d3),%fp1 |mul by 10**(d3_bit_no) | |
333 | ap_p_en: | |
334 | addl #12,%d3 |inc d3 to next rtable entry | |
335 | tstl %d0 |check if d0 is zero | |
336 | bnes ap_p_el |if not, get next bit | |
337 | fmulx %fp1,%fp0 |mul mantissa by 10**(no_bits_shifted) | |
338 | bra pwrten |go calc pwrten | |
339 | | | |
340 | | This section handles a negative adjusted exponent. | |
341 | | | |
342 | ap_st_n: | |
343 | clrl %d1 |clr counter | |
344 | moveql #2,%d5 |set up d5 to point to lword 3 | |
345 | movel (%a0,%d5.L*4),%d4 |get lword 3 | |
346 | bnes ap_n_cl |if not zero, check digits | |
347 | subl #1,%d5 |dec d5 to point to lword 2 | |
348 | addql #8,%d1 |inc counter by 8 | |
349 | movel (%a0,%d5.L*4),%d4 |get lword 2 | |
350 | ap_n_cl: | |
351 | movel #28,%d3 |point to last digit | |
352 | moveql #7,%d2 |init digit counter | |
353 | ap_n_gd: | |
354 | bfextu %d4{%d3:#4},%d0 |get digit | |
355 | bnes ap_n_fx |if non-zero, go to exp fix | |
356 | subql #4,%d3 |point to previous digit | |
357 | addql #1,%d1 |inc digit counter | |
358 | dbf %d2,ap_n_gd |get next digit | |
359 | ap_n_fx: | |
360 | movel %d1,%d0 |copy counter to d0 | |
361 | movel L_SCR1(%a6),%d1 |get adjusted exp from memory | |
362 | subl %d0,%d1 |subtract count from exp | |
363 | bgts ap_n_fm |if still pos, go fix mantissa | |
364 | negl %d1 |take abs of exp and clr SE | |
365 | movel (%a0),%d4 |load lword 1 to d4 | |
366 | andl #0xbfffffff,%d4 | and clr SE in d4 | |
367 | andl #0xbfffffff,(%a0) | and in memory | |
368 | | | |
369 | | Calculate the mantissa multiplier to compensate for the appending of | |
370 | | zeros to the mantissa. | |
371 | | | |
372 | ap_n_fm: | |
373 | movel #PTENRN,%a1 |get address of power-of-ten table | |
374 | clrl %d3 |init table index | |
375 | fmoves FONE,%fp1 |init fp1 to 1 | |
376 | moveql #3,%d2 |init d2 to count bits in counter | |
377 | ap_n_el: | |
378 | asrl #1,%d0 |shift lsb into carry | |
379 | bccs ap_n_en |if 1, mul fp1 by pwrten factor | |
380 | fmulx (%a1,%d3),%fp1 |mul by 10**(d3_bit_no) | |
381 | ap_n_en: | |
382 | addl #12,%d3 |inc d3 to next rtable entry | |
383 | tstl %d0 |check if d0 is zero | |
384 | bnes ap_n_el |if not, get next bit | |
385 | fdivx %fp1,%fp0 |div mantissa by 10**(no_bits_shifted) | |
386 | | | |
387 | | | |
388 | | Calculate power-of-ten factor from adjusted and shifted exponent. | |
389 | | | |
390 | | Register usage: | |
391 | | | |
392 | | pwrten: | |
393 | | (*) d0: temp | |
394 | | ( ) d1: exponent | |
395 | | (*) d2: {FPCR[6:5],SM,SE} as index in RTABLE; temp | |
396 | | (*) d3: FPCR work copy | |
397 | | ( ) d4: first word of bcd | |
398 | | (*) a1: RTABLE pointer | |
399 | | calc_p: | |
400 | | (*) d0: temp | |
401 | | ( ) d1: exponent | |
402 | | (*) d3: PWRTxx table index | |
403 | | ( ) a0: pointer to working copy of bcd | |
404 | | (*) a1: PWRTxx pointer | |
405 | | (*) fp1: power-of-ten accumulator | |
406 | | | |
407 | | Pwrten calculates the exponent factor in the selected rounding mode | |
408 | | according to the following table: | |
409 | | | |
410 | | Sign of Mant Sign of Exp Rounding Mode PWRTEN Rounding Mode | |
411 | | | |
412 | | ANY ANY RN RN | |
413 | | | |
414 | | + + RP RP | |
415 | | - + RP RM | |
416 | | + - RP RM | |
417 | | - - RP RP | |
418 | | | |
419 | | + + RM RM | |
420 | | - + RM RP | |
421 | | + - RM RP | |
422 | | - - RM RM | |
423 | | | |
424 | | + + RZ RM | |
425 | | - + RZ RM | |
426 | | + - RZ RP | |
427 | | - - RZ RP | |
428 | | | |
429 | | | |
430 | pwrten: | |
431 | movel USER_FPCR(%a6),%d3 |get user's FPCR | |
432 | bfextu %d3{#26:#2},%d2 |isolate rounding mode bits | |
433 | movel (%a0),%d4 |reload 1st bcd word to d4 | |
434 | asll #2,%d2 |format d2 to be | |
435 | bfextu %d4{#0:#2},%d0 | {FPCR[6],FPCR[5],SM,SE} | |
436 | addl %d0,%d2 |in d2 as index into RTABLE | |
437 | leal RTABLE,%a1 |load rtable base | |
438 | moveb (%a1,%d2),%d0 |load new rounding bits from table | |
439 | clrl %d3 |clear d3 to force no exc and extended | |
440 | bfins %d0,%d3{#26:#2} |stuff new rounding bits in FPCR | |
441 | fmovel %d3,%FPCR |write new FPCR | |
442 | asrl #1,%d0 |write correct PTENxx table | |
443 | bccs not_rp |to a1 | |
444 | leal PTENRP,%a1 |it is RP | |
445 | bras calc_p |go to init section | |
446 | not_rp: | |
447 | asrl #1,%d0 |keep checking | |
448 | bccs not_rm | |
449 | leal PTENRM,%a1 |it is RM | |
450 | bras calc_p |go to init section | |
451 | not_rm: | |
452 | leal PTENRN,%a1 |it is RN | |
453 | calc_p: | |
454 | movel %d1,%d0 |copy exp to d0;use d0 | |
455 | bpls no_neg |if exp is negative, | |
456 | negl %d0 |invert it | |
457 | orl #0x40000000,(%a0) |and set SE bit | |
458 | no_neg: | |
459 | clrl %d3 |table index | |
460 | fmoves FONE,%fp1 |init fp1 to 1 | |
461 | e_loop: | |
462 | asrl #1,%d0 |shift next bit into carry | |
463 | bccs e_next |if zero, skip the mul | |
464 | fmulx (%a1,%d3),%fp1 |mul by 10**(d3_bit_no) | |
465 | e_next: | |
466 | addl #12,%d3 |inc d3 to next rtable entry | |
467 | tstl %d0 |check if d0 is zero | |
468 | bnes e_loop |not zero, continue shifting | |
469 | | | |
470 | | | |
471 | | Check the sign of the adjusted exp and make the value in fp0 the | |
472 | | same sign. If the exp was pos then multiply fp1*fp0; | |
473 | | else divide fp0/fp1. | |
474 | | | |
475 | | Register Usage: | |
476 | | norm: | |
477 | | ( ) a0: pointer to working bcd value | |
478 | | (*) fp0: mantissa accumulator | |
479 | | ( ) fp1: scaling factor - 10**(abs(exp)) | |
480 | | | |
481 | norm: | |
482 | btst #30,(%a0) |test the sign of the exponent | |
483 | beqs mul |if clear, go to multiply | |
484 | div: | |
485 | fdivx %fp1,%fp0 |exp is negative, so divide mant by exp | |
486 | bras end_dec | |
487 | mul: | |
488 | fmulx %fp1,%fp0 |exp is positive, so multiply by exp | |
489 | | | |
490 | | | |
491 | | Clean up and return with result in fp0. | |
492 | | | |
493 | | If the final mul/div in decbin incurred an inex exception, | |
494 | | it will be inex2, but will be reported as inex1 by get_op. | |
495 | | | |
496 | end_dec: | |
497 | fmovel %FPSR,%d0 |get status register | |
498 | bclrl #inex2_bit+8,%d0 |test for inex2 and clear it | |
499 | fmovel %d0,%FPSR |return status reg w/o inex2 | |
500 | beqs no_exc |skip this if no exc | |
501 | orl #inx1a_mask,USER_FPSR(%a6) |set inex1/ainex | |
502 | no_exc: | |
503 | moveml (%a7)+,%d2-%d5 | |
504 | rts | |
505 | |end |