1 /*
2 * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /*
25 * @test
26 * @bug 6934604
27 *
28 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox
29 * compiler.eliminateAutobox.TestByteBoxing
30 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox
31 * -XX:CompileCommand=exclude,compiler.eliminateAutobox.TestByteBoxing::dummy
32 * -XX:CompileCommand=exclude,compiler.eliminateAutobox.TestByteBoxing::foo
33 * -XX:CompileCommand=exclude,compiler.eliminateAutobox.TestByteBoxing::foob
34 * compiler.eliminateAutobox.TestByteBoxing
35 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-EliminateAutoBox
36 * -XX:CompileCommand=exclude,compiler.eliminateAutobox.TestByteBoxing::dummy
37 * -XX:CompileCommand=exclude,compiler.eliminateAutobox.TestByteBoxing::foo
38 * -XX:CompileCommand=exclude,compiler.eliminateAutobox.TestByteBoxing::foob
39 * compiler.eliminateAutobox.TestByteBoxing
40 */
41
42 package compiler.eliminateAutobox;
43
44 public class TestByteBoxing {
45
46 static final Byte ibc = new Byte((byte)1);
47
48 //===============================================
49 // Non-inlined methods to test deoptimization info
50 static void dummy() { }
51 static byte foo(byte i) { return i; }
52 static Byte foob(byte i) { return Byte.valueOf(i); }
53
54
55 static byte simple(byte i) {
56 Byte ib = new Byte(i);
57 return ib;
58 }
59
60 static byte simpleb(byte i) {
61 Byte ib = Byte.valueOf(i);
62 return ib;
63 }
64
65 static byte simplec() {
66 Byte ib = ibc;
67 return ib;
68 }
69
70 static byte simplef(byte i) {
71 Byte ib = foob(i);
72 return ib;
73 }
74
75 static byte simplep(Byte ib) {
76 return ib;
77 }
78
79 static byte simple2(byte i) {
80 Byte ib1 = new Byte(i);
81 Byte ib2 = new Byte((byte)(i+1));
82 return (byte)(ib1 + ib2);
83 }
84
85 static byte simpleb2(byte i) {
86 Byte ib1 = Byte.valueOf(i);
87 Byte ib2 = Byte.valueOf((byte)(i+1));
88 return (byte)(ib1 + ib2);
89 }
90
91 static byte simplem2(byte i) {
92 Byte ib1 = new Byte(i);
93 Byte ib2 = Byte.valueOf((byte)(i+1));
94 return (byte)(ib1 + ib2);
95 }
96
97 static byte simplep2(byte i, Byte ib1) {
98 Byte ib2 = Byte.valueOf((byte)(i+1));
99 return (byte)(ib1 + ib2);
100 }
101
102 static byte simplec2(byte i) {
103 Byte ib1 = ibc;
104 Byte ib2 = Byte.valueOf((byte)(i+1));
105 return (byte)(ib1 + ib2);
106 }
107
108 //===============================================
109 static byte test(byte i) {
110 Byte ib = new Byte(i);
111 if ((i&1) == 0)
112 ib = (byte)(i+1);
113 return ib;
114 }
115
116 static byte testb(byte i) {
117 Byte ib = i;
118 if ((i&1) == 0)
119 ib = (byte)(i+1);
120 return ib;
121 }
122
123 static byte testm(byte i) {
124 Byte ib = i;
125 if ((i&1) == 0)
126 ib = new Byte((byte)(i+1));
127 return ib;
128 }
129
130 static byte testp(byte i, Byte ib) {
131 if ((i&1) == 0)
132 ib = new Byte((byte)(i+1));
133 return ib;
134 }
135
136 static byte testc(byte i) {
137 Byte ib = ibc;
138 if ((i&1) == 0)
139 ib = new Byte((byte)(i+1));
140 return ib;
141 }
142
143 static byte test2(byte i) {
144 Byte ib1 = new Byte(i);
145 Byte ib2 = new Byte((byte)(i+1));
146 if ((i&1) == 0) {
147 ib1 = new Byte((byte)(i+1));
148 ib2 = new Byte((byte)(i+2));
149 }
150 return (byte)(ib1+ib2);
151 }
152
153 static byte testb2(byte i) {
154 Byte ib1 = i;
155 Byte ib2 = (byte)(i+1);
156 if ((i&1) == 0) {
157 ib1 = (byte)(i+1);
158 ib2 = (byte)(i+2);
159 }
160 return (byte)(ib1 + ib2);
161 }
162
163 static byte testm2(byte i) {
164 Byte ib1 = new Byte(i);
165 Byte ib2 = (byte)(i+1);
166 if ((i&1) == 0) {
167 ib1 = new Byte((byte)(i+1));
168 ib2 = (byte)(i+2);
169 }
170 return (byte)(ib1 + ib2);
171 }
172
173 static byte testp2(byte i, Byte ib1) {
174 Byte ib2 = (byte)(i+1);
175 if ((i&1) == 0) {
176 ib1 = new Byte((byte)(i+1));
177 ib2 = (byte)(i+2);
178 }
179 return (byte)(ib1 + ib2);
180 }
181
182 static byte testc2(byte i) {
183 Byte ib1 = ibc;
184 Byte ib2 = (byte)(i+1);
185 if ((i&1) == 0) {
186 ib1 = (byte)(ibc+1);
187 ib2 = (byte)(i+2);
188 }
189 return (byte)(ib1 + ib2);
190 }
191
192 //===============================================
193 static byte sum(byte[] a) {
194 byte result = 1;
195 for (Byte i : a)
196 result += i;
197 return result;
198 }
199
200 static byte sumb(byte[] a) {
201 Byte result = 1;
202 for (Byte i : a)
203 result = (byte)(result + i);
204 return result;
205 }
206
207 static byte sumc(byte[] a) {
208 Byte result = ibc;
209 for (Byte i : a)
210 result = (byte)(result + i);
211 return result;
212 }
213
214 static byte sumf(byte[] a) {
215 Byte result = foob((byte)1);
216 for (Byte i : a)
217 result = (byte)(result + i);
218 return result;
219 }
220
221 static byte sump(byte[] a, Byte result) {
222 for (Byte i : a)
223 result = (byte)(result + i);
224 return result;
225 }
226
227 static byte sum2(byte[] a) {
228 byte result1 = 1;
229 byte result2 = 1;
230 for (Byte i : a) {
231 result1 += i;
232 result2 += i + 1;
233 }
234 return (byte)(result1 + result2);
235 }
236
237 static byte sumb2(byte[] a) {
238 Byte result1 = 1;
239 Byte result2 = 1;
240 for (Byte i : a) {
241 result1 = (byte)(result1 + i);
242 result2 = (byte)(result2 + i + 1);
243 }
244 return (byte)(result1 + result2);
245 }
246
247 static byte summ2(byte[] a) {
248 Byte result1 = 1;
249 Byte result2 = new Byte((byte)1);
250 for (Byte i : a) {
251 result1 = (byte)(result1 + i);
252 result2 = (byte)(result2 + new Byte((byte)(i + 1)));
253 }
254 return (byte)(result1 + result2);
255 }
256
257 static byte sump2(byte[] a, Byte result2) {
258 Byte result1 = 1;
259 for (Byte i : a) {
260 result1 = (byte)(result1 + i);
261 result2 = (byte)(result2 + i + 1);
262 }
263 return (byte)(result1 + result2);
264 }
265
266 static byte sumc2(byte[] a) {
267 Byte result1 = 1;
268 Byte result2 = ibc;
269 for (Byte i : a) {
270 result1 = (byte)(result1 + i);
271 result2 = (byte)(result2 + i + ibc);
272 }
273 return (byte)(result1 + result2);
274 }
275
276 //===============================================
277 static byte remi_sum() {
278 Byte j = new Byte((byte)1);
279 for (int i = 0; i< 1000; i++) {
280 j = new Byte((byte)(j + 1));
281 }
282 return j;
283 }
284
285 static byte remi_sumb() {
286 Byte j = Byte.valueOf((byte)1);
287 for (int i = 0; i< 1000; i++) {
288 j = (byte)(j + 1);
289 }
290 return j;
291 }
292
293 static byte remi_sumf() {
294 Byte j = foob((byte)1);
295 for (int i = 0; i< 1000; i++) {
296 j = (byte)(j + 1);
297 }
298 return j;
299 }
300
301 static byte remi_sump(Byte j) {
302 for (int i = 0; i< 1000; i++) {
303 j = new Byte((byte)(j + 1));
304 }
305 return j;
306 }
307
308 static byte remi_sumc() {
309 Byte j = ibc;
310 for (int i = 0; i< 1000; i++) {
311 j = (byte)(j + ibc);
312 }
313 return j;
314 }
315
316 static byte remi_sum2() {
317 Byte j1 = new Byte((byte)1);
318 Byte j2 = new Byte((byte)1);
319 for (int i = 0; i< 1000; i++) {
320 j1 = new Byte((byte)(j1 + 1));
321 j2 = new Byte((byte)(j2 + 2));
322 }
323 return (byte)(j1 + j2);
324 }
325
326 static byte remi_sumb2() {
327 Byte j1 = Byte.valueOf((byte)1);
328 Byte j2 = Byte.valueOf((byte)1);
329 for (int i = 0; i< 1000; i++) {
330 j1 = (byte)(j1 + 1);
331 j2 = (byte)(j2 + 2);
332 }
333 return (byte)(j1 + j2);
334 }
335
336 static byte remi_summ2() {
337 Byte j1 = new Byte((byte)1);
338 Byte j2 = Byte.valueOf((byte)1);
339 for (int i = 0; i< 1000; i++) {
340 j1 = new Byte((byte)(j1 + 1));
341 j2 = (byte)(j2 + 2);
342 }
343 return (byte)(j1 + j2);
344 }
345
346 static byte remi_sump2(Byte j1) {
347 Byte j2 = Byte.valueOf((byte)1);
348 for (int i = 0; i< 1000; i++) {
349 j1 = new Byte((byte)(j1 + 1));
350 j2 = (byte)(j2 + 2);
351 }
352 return (byte)(j1 + j2);
353 }
354
355 static byte remi_sumc2() {
356 Byte j1 = ibc;
357 Byte j2 = Byte.valueOf((byte)1);
358 for (int i = 0; i< 1000; i++) {
359 j1 = (byte)(j1 + ibc);
360 j2 = (byte)(j2 + 2);
361 }
362 return (byte)(j1 + j2);
363 }
364
365
366 //===============================================
367 // Safepointa and debug info for deoptimization
368 static byte simple_deop(byte i) {
369 Byte ib = new Byte(foo(i));
370 dummy();
371 return ib;
372 }
373
374 static byte simpleb_deop(byte i) {
375 Byte ib = Byte.valueOf(foo(i));
376 dummy();
377 return ib;
378 }
379
380 static byte simplef_deop(byte i) {
381 Byte ib = foob(i);
382 dummy();
383 return ib;
384 }
385
386 static byte simplep_deop(Byte ib) {
387 dummy();
388 return ib;
389 }
390
391 static byte simplec_deop(byte i) {
392 Byte ib = ibc;
393 dummy();
394 return ib;
395 }
396
397 static byte test_deop(byte i) {
398 Byte ib = new Byte(foo(i));
399 if ((i&1) == 0)
400 ib = foo((byte)(i+1));
401 dummy();
402 return ib;
403 }
404
405 static byte testb_deop(byte i) {
406 Byte ib = foo(i);
407 if ((i&1) == 0)
408 ib = foo((byte)(i+1));
409 dummy();
410 return ib;
411 }
412
413 static byte testf_deop(byte i) {
414 Byte ib = foob(i);
415 if ((i&1) == 0)
416 ib = foo((byte)(i+1));
417 dummy();
418 return ib;
419 }
420
421 static byte testp_deop(byte i, Byte ib) {
422 if ((i&1) == 0)
423 ib = foo((byte)(i+1));
424 dummy();
425 return ib;
426 }
427
428 static byte testc_deop(byte i) {
429 Byte ib = ibc;
430 if ((i&1) == 0)
431 ib = foo((byte)(i+1));
432 dummy();
433 return ib;
434 }
435
436 static byte sum_deop(byte[] a) {
437 byte result = 1;
438 for (Byte i : a)
439 result += foo(i);
440 dummy();
441 return result;
442 }
443
444 static byte sumb_deop(byte[] a) {
445 Byte result = 1;
446 for (Byte i : a)
447 result = (byte)(result + foo(i));
448 dummy();
449 return result;
450 }
451
452 static byte sumf_deop(byte[] a) {
453 Byte result = 1;
454 for (Byte i : a)
455 result = (byte)(result + foob(i));
456 dummy();
457 return result;
458 }
459
460 static byte sump_deop(byte[] a, Byte result) {
461 for (Byte i : a)
462 result = (byte)(result + foob(i));
463 dummy();
464 return result;
465 }
466
467 static byte sumc_deop(byte[] a) {
468 Byte result = ibc;
469 for (Byte i : a)
470 result = (byte)(result + foo(i));
471 dummy();
472 return result;
473 }
474
475 static byte remi_sum_deop() {
476 Byte j = new Byte(foo((byte)1));
477 for (int i = 0; i< 1000; i++) {
478 j = new Byte(foo((byte)(j + 1)));
479 }
480 dummy();
481 return j;
482 }
483
484 static byte remi_sumb_deop() {
485 Byte j = Byte.valueOf(foo((byte)1));
486 for (int i = 0; i< 1000; i++) {
487 j = foo((byte)(j + 1));
488 }
489 dummy();
490 return j;
491 }
492
493 static byte remi_sumf_deop() {
494 Byte j = foob((byte)1);
495 for (int i = 0; i< 1000; i++) {
496 j = foo((byte)(j + 1));
497 }
498 dummy();
499 return j;
500 }
501
502 static byte remi_sump_deop(Byte j) {
503 for (int i = 0; i< 1000; i++) {
504 j = foo((byte)(j + 1));
505 }
506 dummy();
507 return j;
508 }
509
510 static byte remi_sumc_deop() {
511 Byte j = ibc;
512 for (int i = 0; i< 1000; i++) {
513 j = foo((byte)(j + 1));
514 }
515 dummy();
516 return j;
517 }
518
519 //===============================================
520 // Conditional increment
521 static byte remi_sum_cond() {
522 Byte j = new Byte((byte)1);
523 for (int i = 0; i< 1000; i++) {
524 if ((i&1) == 0) {
525 j = new Byte((byte)(j + 1));
526 }
527 }
528 return j;
529 }
530
531 static byte remi_sumb_cond() {
532 Byte j = Byte.valueOf((byte)1);
533 for (int i = 0; i< 1000; i++) {
534 if ((i&1) == 0) {
535 j = (byte)(j + 1);
536 }
537 }
538 return j;
539 }
540
541 static byte remi_sumf_cond() {
542 Byte j = foob((byte)1);
543 for (int i = 0; i< 1000; i++) {
544 if ((i&1) == 0) {
545 j = (byte)(j + 1);
546 }
547 }
548 return j;
549 }
550
551 static byte remi_sump_cond(Byte j) {
552 for (int i = 0; i< 1000; i++) {
553 if ((i&1) == 0) {
554 j = (byte)(j + 1);
555 }
556 }
557 return j;
558 }
559
560 static byte remi_sumc_cond() {
561 Byte j = ibc;
562 for (int i = 0; i< 1000; i++) {
563 if ((i&1) == 0) {
564 j = (byte)(j + ibc);
565 }
566 }
567 return j;
568 }
569
570 static byte remi_sum2_cond() {
571 Byte j1 = new Byte((byte)1);
572 Byte j2 = new Byte((byte)1);
573 for (int i = 0; i< 1000; i++) {
574 if ((i&1) == 0) {
575 j1 = new Byte((byte)(j1 + 1));
576 } else {
577 j2 = new Byte((byte)(j2 + 2));
578 }
579 }
580 return (byte)(j1 + j2);
581 }
582
583 static byte remi_sumb2_cond() {
584 Byte j1 = Byte.valueOf((byte)1);
585 Byte j2 = Byte.valueOf((byte)1);
586 for (int i = 0; i< 1000; i++) {
587 if ((i&1) == 0) {
588 j1 = (byte)(j1 + 1);
589 } else {
590 j2 = (byte)(j2 + 2);
591 }
592 }
593 return (byte)(j1 + j2);
594 }
595
596 static byte remi_summ2_cond() {
597 Byte j1 = new Byte((byte)1);
598 Byte j2 = Byte.valueOf((byte)1);
599 for (int i = 0; i< 1000; i++) {
600 if ((i&1) == 0) {
601 j1 = new Byte((byte)(j1 + 1));
602 } else {
603 j2 = (byte)(j2 + 2);
604 }
605 }
606 return (byte)(j1 + j2);
607 }
608
609 static byte remi_sump2_cond(Byte j1) {
610 Byte j2 = Byte.valueOf((byte)1);
611 for (int i = 0; i< 1000; i++) {
612 if ((i&1) == 0) {
613 j1 = new Byte((byte)(j1 + 1));
614 } else {
615 j2 = (byte)(j2 + 2);
616 }
617 }
618 return (byte)(j1 + j2);
619 }
620
621 static byte remi_sumc2_cond() {
622 Byte j1 = ibc;
623 Byte j2 = Byte.valueOf((byte)1);
624 for (int i = 0; i< 1000; i++) {
625 if ((i&1) == 0) {
626 j1 = (byte)(j1 + ibc);
627 } else {
628 j2 = (byte)(j2 + 2);
629 }
630 }
631 return (byte)(j1 + j2);
632 }
633
634
635 public static void main(String[] args) {
636 final int ntests = 70;
637
638 String[] test_name = new String[] {
639 "simple", "simpleb", "simplec", "simplef", "simplep",
640 "simple2", "simpleb2", "simplec2", "simplem2", "simplep2",
641 "simple_deop", "simpleb_deop", "simplec_deop", "simplef_deop", "simplep_deop",
642 "test", "testb", "testc", "testm", "testp",
643 "test2", "testb2", "testc2", "testm2", "testp2",
644 "test_deop", "testb_deop", "testc_deop", "testf_deop", "testp_deop",
645 "sum", "sumb", "sumc", "sumf", "sump",
646 "sum2", "sumb2", "sumc2", "summ2", "sump2",
647 "sum_deop", "sumb_deop", "sumc_deop", "sumf_deop", "sump_deop",
648 "remi_sum", "remi_sumb", "remi_sumc", "remi_sumf", "remi_sump",
649 "remi_sum2", "remi_sumb2", "remi_sumc2", "remi_summ2", "remi_sump2",
650 "remi_sum_deop", "remi_sumb_deop", "remi_sumc_deop", "remi_sumf_deop", "remi_sump_deop",
651 "remi_sum_cond", "remi_sumb_cond", "remi_sumc_cond", "remi_sumf_cond", "remi_sump_cond",
652 "remi_sum2_cond", "remi_sumb2_cond", "remi_sumc2_cond", "remi_summ2_cond", "remi_sump2_cond"
653 };
654
655 final int[] val = new int[] {
656 -5488, -5488, 12000, -5488, -5488,
657 1024, 1024, -5552, 1024, 1024,
658 -5488, -5488, 12000, -5488, -5488,
659 512, 512, 6256, 512, 512,
660 13024, 13024, -5584, 13024, 13024,
661 512, 512, 6256, 512, 512,
662 45, 45, 45, 45, 45,
663 66, 66, 66, 66, 66,
664 45, 45, 45, 45, 45,
665 -23, -23, -23, -23, -23,
666 -70, -70, -70, -70, -70,
667 -23, -23, -23, -23, -23,
668 -11, -11, -11, -11, -11,
669 -34, -34, -34, -34, -34
670 };
671
672 int[] res = new int[ntests];
673 for (int i = 0; i < ntests; i++) {
674 res[i] = 0;
675 }
676
677
678 for (int i = 0; i < 12000; i++) {
679 res[0] += simple((byte)i);
680 res[1] += simpleb((byte)i);
681 res[2] += simplec();
682 res[3] += simplef((byte)i);
683 res[4] += simplep((byte)i);
684
685 res[5] += simple2((byte)i);
686 res[6] += simpleb2((byte)i);
687 res[7] += simplec2((byte)i);
688 res[8] += simplem2((byte)i);
689 res[9] += simplep2((byte)i, (byte)i);
690
691 res[10] += simple_deop((byte)i);
692 res[11] += simpleb_deop((byte)i);
693 res[12] += simplec_deop((byte)i);
694 res[13] += simplef_deop((byte)i);
695 res[14] += simplep_deop((byte)i);
696
697 res[15] += test((byte)i);
698 res[16] += testb((byte)i);
699 res[17] += testc((byte)i);
700 res[18] += testm((byte)i);
701 res[19] += testp((byte)i, (byte)i);
702
703 res[20] += test2((byte)i);
704 res[21] += testb2((byte)i);
705 res[22] += testc2((byte)i);
706 res[23] += testm2((byte)i);
707 res[24] += testp2((byte)i, (byte)i);
708
709 res[25] += test_deop((byte)i);
710 res[26] += testb_deop((byte)i);
711 res[27] += testc_deop((byte)i);
712 res[28] += testf_deop((byte)i);
713 res[29] += testp_deop((byte)i, (byte)i);
714 }
715
716 byte[] ia = new byte[1000];
717 for (int i = 0; i < 1000; i++) {
718 ia[i] = (byte)i;
719 }
720
721 for (int i = 0; i < 100; i++) {
722 res[30] = sum(ia);
723 res[31] = sumb(ia);
724 res[32] = sumc(ia);
725 res[33] = sumf(ia);
726 res[34] = sump(ia, (byte)1);
727
728 res[35] = sum2(ia);
729 res[36] = sumb2(ia);
730 res[37] = sumc2(ia);
731 res[38] = summ2(ia);
732 res[39] = sump2(ia, (byte)1);
733
734 res[40] = sum_deop(ia);
735 res[41] = sumb_deop(ia);
736 res[42] = sumc_deop(ia);
737 res[43] = sumf_deop(ia);
738 res[44] = sump_deop(ia, (byte)1);
739
740 res[45] = remi_sum();
741 res[46] = remi_sumb();
742 res[47] = remi_sumc();
743 res[48] = remi_sumf();
744 res[49] = remi_sump((byte)1);
745
746 res[50] = remi_sum2();
747 res[51] = remi_sumb2();
748 res[52] = remi_sumc2();
749 res[53] = remi_summ2();
750 res[54] = remi_sump2((byte)1);
751
752 res[55] = remi_sum_deop();
753 res[56] = remi_sumb_deop();
754 res[57] = remi_sumc_deop();
755 res[58] = remi_sumf_deop();
756 res[59] = remi_sump_deop((byte)1);
757
758 res[60] = remi_sum_cond();
759 res[61] = remi_sumb_cond();
760 res[62] = remi_sumc_cond();
761 res[63] = remi_sumf_cond();
762 res[64] = remi_sump_cond((byte)1);
763
764 res[65] = remi_sum2_cond();
765 res[66] = remi_sumb2_cond();
766 res[67] = remi_sumc2_cond();
767 res[68] = remi_summ2_cond();
768 res[69] = remi_sump2_cond((byte)1);
769 }
770
771 int failed = 0;
772 for (int i = 0; i < ntests; i++) {
773 if (res[i] != val[i]) {
774 System.err.println(test_name[i] + ": " + res[i] + " != " + val[i]);
775 failed++;
776 }
777 }
778 if (failed > 0) {
779 System.err.println("Failed " + failed + " tests.");
780 throw new InternalError();
781 } else {
782 System.out.println("Passed.");
783 }
784 }
785 }