put_long_double.pass.cpp revision f5256e16dfc425c1d466f6308d4026d529ce9e0b 
1//===----------------------------------------------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10// <locale>
11
12// class num_put<charT, OutputIterator>
13
14// iter_type put(iter_type s, ios_base& iob, char_type fill, long double v) const;
15
16#include <locale>
17#include <ios>
18#include <cassert>
19#include <streambuf>
20#include <cmath>
21#include "iterators.h"
22
23typedef std::num_put<char, output_iterator<char*> > F;
24
25class my_facet
26    : public F
27{
28public:
29    explicit my_facet(std::size_t refs = 0)
30        : F(refs) {}
31};
32
33class my_numpunct
34    : public std::numpunct<char>
35{
36public:
37    my_numpunct() : std::numpunct<char>() {}
38
39protected:
40    virtual char_type do_decimal_point() const {return ';';}
41    virtual char_type do_thousands_sep() const {return '_';}
42    virtual std::string do_grouping() const {return std::string("\1\2\3");}
43};
44
45void test1()
46{
47    char str[200];
48    output_iterator<char*> iter;
49    std::locale lc = std::locale::classic();
50    std::locale lg(lc, new my_numpunct);
51    const my_facet f(1);
52    {
53        long double v = +0.;
54        std::ios ios(0);
55        // %g
56        {
57            ios.precision(0);
58            {
59                nouppercase(ios);
60                {
61                    noshowpos(ios);
62                    {
63                        noshowpoint(ios);
64                        {
65                            ios.imbue(lc);
66                            {
67                                ios.width(0);
68                                {
69                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
70                                    std::string ex(str, iter.base());
71                                    assert(ex == "0");
72                                    assert(ios.width() == 0);
73                                }
74                                ios.width(25);
75                                left(ios);
76                                {
77                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
78                                    std::string ex(str, iter.base());
79                                    assert(ex == "0************************");
80                                    assert(ios.width() == 0);
81                                }
82                                ios.width(25);
83                                right(ios);
84                                {
85                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
86                                    std::string ex(str, iter.base());
87                                    assert(ex == "************************0");
88                                    assert(ios.width() == 0);
89                                }
90                                ios.width(25);
91                                internal(ios);
92                                {
93                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
94                                    std::string ex(str, iter.base());
95                                    assert(ex == "************************0");
96                                    assert(ios.width() == 0);
97                                }
98                            }
99                            ios.imbue(lg);
100                            {
101                                ios.width(0);
102                                {
103                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
104                                    std::string ex(str, iter.base());
105                                    assert(ex == "0");
106                                    assert(ios.width() == 0);
107                                }
108                                ios.width(25);
109                                left(ios);
110                                {
111                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
112                                    std::string ex(str, iter.base());
113                                    assert(ex == "0************************");
114                                    assert(ios.width() == 0);
115                                }
116                                ios.width(25);
117                                right(ios);
118                                {
119                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
120                                    std::string ex(str, iter.base());
121                                    assert(ex == "************************0");
122                                    assert(ios.width() == 0);
123                                }
124                                ios.width(25);
125                                internal(ios);
126                                {
127                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
128                                    std::string ex(str, iter.base());
129                                    assert(ex == "************************0");
130                                    assert(ios.width() == 0);
131                                }
132                            }
133                        }
134                        showpoint(ios);
135                        {
136                            ios.imbue(lc);
137                            {
138                                ios.width(0);
139                                {
140                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
141                                    std::string ex(str, iter.base());
142                                    assert(ex == "0.");
143                                    assert(ios.width() == 0);
144                                }
145                                ios.width(25);
146                                left(ios);
147                                {
148                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
149                                    std::string ex(str, iter.base());
150                                    assert(ex == "0.***********************");
151                                    assert(ios.width() == 0);
152                                }
153                                ios.width(25);
154                                right(ios);
155                                {
156                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
157                                    std::string ex(str, iter.base());
158                                    assert(ex == "***********************0.");
159                                    assert(ios.width() == 0);
160                                }
161                                ios.width(25);
162                                internal(ios);
163                                {
164                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
165                                    std::string ex(str, iter.base());
166                                    assert(ex == "***********************0.");
167                                    assert(ios.width() == 0);
168                                }
169                            }
170                            ios.imbue(lg);
171                            {
172                                ios.width(0);
173                                {
174                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
175                                    std::string ex(str, iter.base());
176                                    assert(ex == "0;");
177                                    assert(ios.width() == 0);
178                                }
179                                ios.width(25);
180                                left(ios);
181                                {
182                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
183                                    std::string ex(str, iter.base());
184                                    assert(ex == "0;***********************");
185                                    assert(ios.width() == 0);
186                                }
187                                ios.width(25);
188                                right(ios);
189                                {
190                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
191                                    std::string ex(str, iter.base());
192                                    assert(ex == "***********************0;");
193                                    assert(ios.width() == 0);
194                                }
195                                ios.width(25);
196                                internal(ios);
197                                {
198                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
199                                    std::string ex(str, iter.base());
200                                    assert(ex == "***********************0;");
201                                    assert(ios.width() == 0);
202                                }
203                            }
204                        }
205                    }
206                    showpos(ios);
207                    {
208                        noshowpoint(ios);
209                        {
210                            ios.imbue(lc);
211                            {
212                                ios.width(0);
213                                {
214                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
215                                    std::string ex(str, iter.base());
216                                    assert(ex == "+0");
217                                    assert(ios.width() == 0);
218                                }
219                                ios.width(25);
220                                left(ios);
221                                {
222                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
223                                    std::string ex(str, iter.base());
224                                    assert(ex == "+0***********************");
225                                    assert(ios.width() == 0);
226                                }
227                                ios.width(25);
228                                right(ios);
229                                {
230                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
231                                    std::string ex(str, iter.base());
232                                    assert(ex == "***********************+0");
233                                    assert(ios.width() == 0);
234                                }
235                                ios.width(25);
236                                internal(ios);
237                                {
238                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
239                                    std::string ex(str, iter.base());
240                                    assert(ex == "+***********************0");
241                                    assert(ios.width() == 0);
242                                }
243                            }
244                            ios.imbue(lg);
245                            {
246                                ios.width(0);
247                                {
248                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
249                                    std::string ex(str, iter.base());
250                                    assert(ex == "+0");
251                                    assert(ios.width() == 0);
252                                }
253                                ios.width(25);
254                                left(ios);
255                                {
256                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
257                                    std::string ex(str, iter.base());
258                                    assert(ex == "+0***********************");
259                                    assert(ios.width() == 0);
260                                }
261                                ios.width(25);
262                                right(ios);
263                                {
264                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
265                                    std::string ex(str, iter.base());
266                                    assert(ex == "***********************+0");
267                                    assert(ios.width() == 0);
268                                }
269                                ios.width(25);
270                                internal(ios);
271                                {
272                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
273                                    std::string ex(str, iter.base());
274                                    assert(ex == "+***********************0");
275                                    assert(ios.width() == 0);
276                                }
277                            }
278                        }
279                        showpoint(ios);
280                        {
281                            ios.imbue(lc);
282                            {
283                                ios.width(0);
284                                {
285                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
286                                    std::string ex(str, iter.base());
287                                    assert(ex == "+0.");
288                                    assert(ios.width() == 0);
289                                }
290                                ios.width(25);
291                                left(ios);
292                                {
293                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
294                                    std::string ex(str, iter.base());
295                                    assert(ex == "+0.**********************");
296                                    assert(ios.width() == 0);
297                                }
298                                ios.width(25);
299                                right(ios);
300                                {
301                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
302                                    std::string ex(str, iter.base());
303                                    assert(ex == "**********************+0.");
304                                    assert(ios.width() == 0);
305                                }
306                                ios.width(25);
307                                internal(ios);
308                                {
309                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
310                                    std::string ex(str, iter.base());
311                                    assert(ex == "+**********************0.");
312                                    assert(ios.width() == 0);
313                                }
314                            }
315                            ios.imbue(lg);
316                            {
317                                ios.width(0);
318                                {
319                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
320                                    std::string ex(str, iter.base());
321                                    assert(ex == "+0;");
322                                    assert(ios.width() == 0);
323                                }
324                                ios.width(25);
325                                left(ios);
326                                {
327                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
328                                    std::string ex(str, iter.base());
329                                    assert(ex == "+0;**********************");
330                                    assert(ios.width() == 0);
331                                }
332                                ios.width(25);
333                                right(ios);
334                                {
335                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
336                                    std::string ex(str, iter.base());
337                                    assert(ex == "**********************+0;");
338                                    assert(ios.width() == 0);
339                                }
340                                ios.width(25);
341                                internal(ios);
342                                {
343                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
344                                    std::string ex(str, iter.base());
345                                    assert(ex == "+**********************0;");
346                                    assert(ios.width() == 0);
347                                }
348                            }
349                        }
350                    }
351                }
352                uppercase(ios);
353                {
354                    noshowpos(ios);
355                    {
356                        noshowpoint(ios);
357                        {
358                            ios.imbue(lc);
359                            {
360                                ios.width(0);
361                                {
362                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
363                                    std::string ex(str, iter.base());
364                                    assert(ex == "0");
365                                    assert(ios.width() == 0);
366                                }
367                                ios.width(25);
368                                left(ios);
369                                {
370                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
371                                    std::string ex(str, iter.base());
372                                    assert(ex == "0************************");
373                                    assert(ios.width() == 0);
374                                }
375                                ios.width(25);
376                                right(ios);
377                                {
378                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
379                                    std::string ex(str, iter.base());
380                                    assert(ex == "************************0");
381                                    assert(ios.width() == 0);
382                                }
383                                ios.width(25);
384                                internal(ios);
385                                {
386                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
387                                    std::string ex(str, iter.base());
388                                    assert(ex == "************************0");
389                                    assert(ios.width() == 0);
390                                }
391                            }
392                            ios.imbue(lg);
393                            {
394                                ios.width(0);
395                                {
396                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
397                                    std::string ex(str, iter.base());
398                                    assert(ex == "0");
399                                    assert(ios.width() == 0);
400                                }
401                                ios.width(25);
402                                left(ios);
403                                {
404                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
405                                    std::string ex(str, iter.base());
406                                    assert(ex == "0************************");
407                                    assert(ios.width() == 0);
408                                }
409                                ios.width(25);
410                                right(ios);
411                                {
412                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
413                                    std::string ex(str, iter.base());
414                                    assert(ex == "************************0");
415                                    assert(ios.width() == 0);
416                                }
417                                ios.width(25);
418                                internal(ios);
419                                {
420                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
421                                    std::string ex(str, iter.base());
422                                    assert(ex == "************************0");
423                                    assert(ios.width() == 0);
424                                }
425                            }
426                        }
427                        showpoint(ios);
428                        {
429                            ios.imbue(lc);
430                            {
431                                ios.width(0);
432                                {
433                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
434                                    std::string ex(str, iter.base());
435                                    assert(ex == "0.");
436                                    assert(ios.width() == 0);
437                                }
438                                ios.width(25);
439                                left(ios);
440                                {
441                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
442                                    std::string ex(str, iter.base());
443                                    assert(ex == "0.***********************");
444                                    assert(ios.width() == 0);
445                                }
446                                ios.width(25);
447                                right(ios);
448                                {
449                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
450                                    std::string ex(str, iter.base());
451                                    assert(ex == "***********************0.");
452                                    assert(ios.width() == 0);
453                                }
454                                ios.width(25);
455                                internal(ios);
456                                {
457                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
458                                    std::string ex(str, iter.base());
459                                    assert(ex == "***********************0.");
460                                    assert(ios.width() == 0);
461                                }
462                            }
463                            ios.imbue(lg);
464                            {
465                                ios.width(0);
466                                {
467                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
468                                    std::string ex(str, iter.base());
469                                    assert(ex == "0;");
470                                    assert(ios.width() == 0);
471                                }
472                                ios.width(25);
473                                left(ios);
474                                {
475                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
476                                    std::string ex(str, iter.base());
477                                    assert(ex == "0;***********************");
478                                    assert(ios.width() == 0);
479                                }
480                                ios.width(25);
481                                right(ios);
482                                {
483                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
484                                    std::string ex(str, iter.base());
485                                    assert(ex == "***********************0;");
486                                    assert(ios.width() == 0);
487                                }
488                                ios.width(25);
489                                internal(ios);
490                                {
491                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
492                                    std::string ex(str, iter.base());
493                                    assert(ex == "***********************0;");
494                                    assert(ios.width() == 0);
495                                }
496                            }
497                        }
498                    }
499                    showpos(ios);
500                    {
501                        noshowpoint(ios);
502                        {
503                            ios.imbue(lc);
504                            {
505                                ios.width(0);
506                                {
507                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
508                                    std::string ex(str, iter.base());
509                                    assert(ex == "+0");
510                                    assert(ios.width() == 0);
511                                }
512                                ios.width(25);
513                                left(ios);
514                                {
515                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
516                                    std::string ex(str, iter.base());
517                                    assert(ex == "+0***********************");
518                                    assert(ios.width() == 0);
519                                }
520                                ios.width(25);
521                                right(ios);
522                                {
523                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
524                                    std::string ex(str, iter.base());
525                                    assert(ex == "***********************+0");
526                                    assert(ios.width() == 0);
527                                }
528                                ios.width(25);
529                                internal(ios);
530                                {
531                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
532                                    std::string ex(str, iter.base());
533                                    assert(ex == "+***********************0");
534                                    assert(ios.width() == 0);
535                                }
536                            }
537                            ios.imbue(lg);
538                            {
539                                ios.width(0);
540                                {
541                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
542                                    std::string ex(str, iter.base());
543                                    assert(ex == "+0");
544                                    assert(ios.width() == 0);
545                                }
546                                ios.width(25);
547                                left(ios);
548                                {
549                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
550                                    std::string ex(str, iter.base());
551                                    assert(ex == "+0***********************");
552                                    assert(ios.width() == 0);
553                                }
554                                ios.width(25);
555                                right(ios);
556                                {
557                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
558                                    std::string ex(str, iter.base());
559                                    assert(ex == "***********************+0");
560                                    assert(ios.width() == 0);
561                                }
562                                ios.width(25);
563                                internal(ios);
564                                {
565                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
566                                    std::string ex(str, iter.base());
567                                    assert(ex == "+***********************0");
568                                    assert(ios.width() == 0);
569                                }
570                            }
571                        }
572                        showpoint(ios);
573                        {
574                            ios.imbue(lc);
575                            {
576                                ios.width(0);
577                                {
578                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
579                                    std::string ex(str, iter.base());
580                                    assert(ex == "+0.");
581                                    assert(ios.width() == 0);
582                                }
583                                ios.width(25);
584                                left(ios);
585                                {
586                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
587                                    std::string ex(str, iter.base());
588                                    assert(ex == "+0.**********************");
589                                    assert(ios.width() == 0);
590                                }
591                                ios.width(25);
592                                right(ios);
593                                {
594                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
595                                    std::string ex(str, iter.base());
596                                    assert(ex == "**********************+0.");
597                                    assert(ios.width() == 0);
598                                }
599                                ios.width(25);
600                                internal(ios);
601                                {
602                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
603                                    std::string ex(str, iter.base());
604                                    assert(ex == "+**********************0.");
605                                    assert(ios.width() == 0);
606                                }
607                            }
608                            ios.imbue(lg);
609                            {
610                                ios.width(0);
611                                {
612                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
613                                    std::string ex(str, iter.base());
614                                    assert(ex == "+0;");
615                                    assert(ios.width() == 0);
616                                }
617                                ios.width(25);
618                                left(ios);
619                                {
620                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
621                                    std::string ex(str, iter.base());
622                                    assert(ex == "+0;**********************");
623                                    assert(ios.width() == 0);
624                                }
625                                ios.width(25);
626                                right(ios);
627                                {
628                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
629                                    std::string ex(str, iter.base());
630                                    assert(ex == "**********************+0;");
631                                    assert(ios.width() == 0);
632                                }
633                                ios.width(25);
634                                internal(ios);
635                                {
636                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
637                                    std::string ex(str, iter.base());
638                                    assert(ex == "+**********************0;");
639                                    assert(ios.width() == 0);
640                                }
641                            }
642                        }
643                    }
644                }
645            }
646            ios.precision(1);
647            {
648                nouppercase(ios);
649                {
650                    noshowpos(ios);
651                    {
652                        noshowpoint(ios);
653                        {
654                            ios.imbue(lc);
655                            {
656                                ios.width(0);
657                                {
658                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
659                                    std::string ex(str, iter.base());
660                                    assert(ex == "0");
661                                    assert(ios.width() == 0);
662                                }
663                                ios.width(25);
664                                left(ios);
665                                {
666                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
667                                    std::string ex(str, iter.base());
668                                    assert(ex == "0************************");
669                                    assert(ios.width() == 0);
670                                }
671                                ios.width(25);
672                                right(ios);
673                                {
674                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
675                                    std::string ex(str, iter.base());
676                                    assert(ex == "************************0");
677                                    assert(ios.width() == 0);
678                                }
679                                ios.width(25);
680                                internal(ios);
681                                {
682                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
683                                    std::string ex(str, iter.base());
684                                    assert(ex == "************************0");
685                                    assert(ios.width() == 0);
686                                }
687                            }
688                            ios.imbue(lg);
689                            {
690                                ios.width(0);
691                                {
692                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
693                                    std::string ex(str, iter.base());
694                                    assert(ex == "0");
695                                    assert(ios.width() == 0);
696                                }
697                                ios.width(25);
698                                left(ios);
699                                {
700                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
701                                    std::string ex(str, iter.base());
702                                    assert(ex == "0************************");
703                                    assert(ios.width() == 0);
704                                }
705                                ios.width(25);
706                                right(ios);
707                                {
708                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
709                                    std::string ex(str, iter.base());
710                                    assert(ex == "************************0");
711                                    assert(ios.width() == 0);
712                                }
713                                ios.width(25);
714                                internal(ios);
715                                {
716                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
717                                    std::string ex(str, iter.base());
718                                    assert(ex == "************************0");
719                                    assert(ios.width() == 0);
720                                }
721                            }
722                        }
723                        showpoint(ios);
724                        {
725                            ios.imbue(lc);
726                            {
727                                ios.width(0);
728                                {
729                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
730                                    std::string ex(str, iter.base());
731                                    assert(ex == "0.");
732                                    assert(ios.width() == 0);
733                                }
734                                ios.width(25);
735                                left(ios);
736                                {
737                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
738                                    std::string ex(str, iter.base());
739                                    assert(ex == "0.***********************");
740                                    assert(ios.width() == 0);
741                                }
742                                ios.width(25);
743                                right(ios);
744                                {
745                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
746                                    std::string ex(str, iter.base());
747                                    assert(ex == "***********************0.");
748                                    assert(ios.width() == 0);
749                                }
750                                ios.width(25);
751                                internal(ios);
752                                {
753                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
754                                    std::string ex(str, iter.base());
755                                    assert(ex == "***********************0.");
756                                    assert(ios.width() == 0);
757                                }
758                            }
759                            ios.imbue(lg);
760                            {
761                                ios.width(0);
762                                {
763                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
764                                    std::string ex(str, iter.base());
765                                    assert(ex == "0;");
766                                    assert(ios.width() == 0);
767                                }
768                                ios.width(25);
769                                left(ios);
770                                {
771                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
772                                    std::string ex(str, iter.base());
773                                    assert(ex == "0;***********************");
774                                    assert(ios.width() == 0);
775                                }
776                                ios.width(25);
777                                right(ios);
778                                {
779                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
780                                    std::string ex(str, iter.base());
781                                    assert(ex == "***********************0;");
782                                    assert(ios.width() == 0);
783                                }
784                                ios.width(25);
785                                internal(ios);
786                                {
787                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
788                                    std::string ex(str, iter.base());
789                                    assert(ex == "***********************0;");
790                                    assert(ios.width() == 0);
791                                }
792                            }
793                        }
794                    }
795                    showpos(ios);
796                    {
797                        noshowpoint(ios);
798                        {
799                            ios.imbue(lc);
800                            {
801                                ios.width(0);
802                                {
803                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
804                                    std::string ex(str, iter.base());
805                                    assert(ex == "+0");
806                                    assert(ios.width() == 0);
807                                }
808                                ios.width(25);
809                                left(ios);
810                                {
811                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
812                                    std::string ex(str, iter.base());
813                                    assert(ex == "+0***********************");
814                                    assert(ios.width() == 0);
815                                }
816                                ios.width(25);
817                                right(ios);
818                                {
819                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
820                                    std::string ex(str, iter.base());
821                                    assert(ex == "***********************+0");
822                                    assert(ios.width() == 0);
823                                }
824                                ios.width(25);
825                                internal(ios);
826                                {
827                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
828                                    std::string ex(str, iter.base());
829                                    assert(ex == "+***********************0");
830                                    assert(ios.width() == 0);
831                                }
832                            }
833                            ios.imbue(lg);
834                            {
835                                ios.width(0);
836                                {
837                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
838                                    std::string ex(str, iter.base());
839                                    assert(ex == "+0");
840                                    assert(ios.width() == 0);
841                                }
842                                ios.width(25);
843                                left(ios);
844                                {
845                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
846                                    std::string ex(str, iter.base());
847                                    assert(ex == "+0***********************");
848                                    assert(ios.width() == 0);
849                                }
850                                ios.width(25);
851                                right(ios);
852                                {
853                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
854                                    std::string ex(str, iter.base());
855                                    assert(ex == "***********************+0");
856                                    assert(ios.width() == 0);
857                                }
858                                ios.width(25);
859                                internal(ios);
860                                {
861                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
862                                    std::string ex(str, iter.base());
863                                    assert(ex == "+***********************0");
864                                    assert(ios.width() == 0);
865                                }
866                            }
867                        }
868                        showpoint(ios);
869                        {
870                            ios.imbue(lc);
871                            {
872                                ios.width(0);
873                                {
874                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
875                                    std::string ex(str, iter.base());
876                                    assert(ex == "+0.");
877                                    assert(ios.width() == 0);
878                                }
879                                ios.width(25);
880                                left(ios);
881                                {
882                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
883                                    std::string ex(str, iter.base());
884                                    assert(ex == "+0.**********************");
885                                    assert(ios.width() == 0);
886                                }
887                                ios.width(25);
888                                right(ios);
889                                {
890                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
891                                    std::string ex(str, iter.base());
892                                    assert(ex == "**********************+0.");
893                                    assert(ios.width() == 0);
894                                }
895                                ios.width(25);
896                                internal(ios);
897                                {
898                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
899                                    std::string ex(str, iter.base());
900                                    assert(ex == "+**********************0.");
901                                    assert(ios.width() == 0);
902                                }
903                            }
904                            ios.imbue(lg);
905                            {
906                                ios.width(0);
907                                {
908                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
909                                    std::string ex(str, iter.base());
910                                    assert(ex == "+0;");
911                                    assert(ios.width() == 0);
912                                }
913                                ios.width(25);
914                                left(ios);
915                                {
916                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
917                                    std::string ex(str, iter.base());
918                                    assert(ex == "+0;**********************");
919                                    assert(ios.width() == 0);
920                                }
921                                ios.width(25);
922                                right(ios);
923                                {
924                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
925                                    std::string ex(str, iter.base());
926                                    assert(ex == "**********************+0;");
927                                    assert(ios.width() == 0);
928                                }
929                                ios.width(25);
930                                internal(ios);
931                                {
932                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
933                                    std::string ex(str, iter.base());
934                                    assert(ex == "+**********************0;");
935                                    assert(ios.width() == 0);
936                                }
937                            }
938                        }
939                    }
940                }
941                uppercase(ios);
942                {
943                    noshowpos(ios);
944                    {
945                        noshowpoint(ios);
946                        {
947                            ios.imbue(lc);
948                            {
949                                ios.width(0);
950                                {
951                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
952                                    std::string ex(str, iter.base());
953                                    assert(ex == "0");
954                                    assert(ios.width() == 0);
955                                }
956                                ios.width(25);
957                                left(ios);
958                                {
959                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
960                                    std::string ex(str, iter.base());
961                                    assert(ex == "0************************");
962                                    assert(ios.width() == 0);
963                                }
964                                ios.width(25);
965                                right(ios);
966                                {
967                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
968                                    std::string ex(str, iter.base());
969                                    assert(ex == "************************0");
970                                    assert(ios.width() == 0);
971                                }
972                                ios.width(25);
973                                internal(ios);
974                                {
975                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
976                                    std::string ex(str, iter.base());
977                                    assert(ex == "************************0");
978                                    assert(ios.width() == 0);
979                                }
980                            }
981                            ios.imbue(lg);
982                            {
983                                ios.width(0);
984                                {
985                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
986                                    std::string ex(str, iter.base());
987                                    assert(ex == "0");
988                                    assert(ios.width() == 0);
989                                }
990                                ios.width(25);
991                                left(ios);
992                                {
993                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
994                                    std::string ex(str, iter.base());
995                                    assert(ex == "0************************");
996                                    assert(ios.width() == 0);
997                                }
998                                ios.width(25);
999                                right(ios);
1000                                {
1001                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1002                                    std::string ex(str, iter.base());
1003                                    assert(ex == "************************0");
1004                                    assert(ios.width() == 0);
1005                                }
1006                                ios.width(25);
1007                                internal(ios);
1008                                {
1009                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1010                                    std::string ex(str, iter.base());
1011                                    assert(ex == "************************0");
1012                                    assert(ios.width() == 0);
1013                                }
1014                            }
1015                        }
1016                        showpoint(ios);
1017                        {
1018                            ios.imbue(lc);
1019                            {
1020                                ios.width(0);
1021                                {
1022                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1023                                    std::string ex(str, iter.base());
1024                                    assert(ex == "0.");
1025                                    assert(ios.width() == 0);
1026                                }
1027                                ios.width(25);
1028                                left(ios);
1029                                {
1030                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1031                                    std::string ex(str, iter.base());
1032                                    assert(ex == "0.***********************");
1033                                    assert(ios.width() == 0);
1034                                }
1035                                ios.width(25);
1036                                right(ios);
1037                                {
1038                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1039                                    std::string ex(str, iter.base());
1040                                    assert(ex == "***********************0.");
1041                                    assert(ios.width() == 0);
1042                                }
1043                                ios.width(25);
1044                                internal(ios);
1045                                {
1046                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1047                                    std::string ex(str, iter.base());
1048                                    assert(ex == "***********************0.");
1049                                    assert(ios.width() == 0);
1050                                }
1051                            }
1052                            ios.imbue(lg);
1053                            {
1054                                ios.width(0);
1055                                {
1056                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1057                                    std::string ex(str, iter.base());
1058                                    assert(ex == "0;");
1059                                    assert(ios.width() == 0);
1060                                }
1061                                ios.width(25);
1062                                left(ios);
1063                                {
1064                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1065                                    std::string ex(str, iter.base());
1066                                    assert(ex == "0;***********************");
1067                                    assert(ios.width() == 0);
1068                                }
1069                                ios.width(25);
1070                                right(ios);
1071                                {
1072                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1073                                    std::string ex(str, iter.base());
1074                                    assert(ex == "***********************0;");
1075                                    assert(ios.width() == 0);
1076                                }
1077                                ios.width(25);
1078                                internal(ios);
1079                                {
1080                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1081                                    std::string ex(str, iter.base());
1082                                    assert(ex == "***********************0;");
1083                                    assert(ios.width() == 0);
1084                                }
1085                            }
1086                        }
1087                    }
1088                    showpos(ios);
1089                    {
1090                        noshowpoint(ios);
1091                        {
1092                            ios.imbue(lc);
1093                            {
1094                                ios.width(0);
1095                                {
1096                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1097                                    std::string ex(str, iter.base());
1098                                    assert(ex == "+0");
1099                                    assert(ios.width() == 0);
1100                                }
1101                                ios.width(25);
1102                                left(ios);
1103                                {
1104                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1105                                    std::string ex(str, iter.base());
1106                                    assert(ex == "+0***********************");
1107                                    assert(ios.width() == 0);
1108                                }
1109                                ios.width(25);
1110                                right(ios);
1111                                {
1112                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1113                                    std::string ex(str, iter.base());
1114                                    assert(ex == "***********************+0");
1115                                    assert(ios.width() == 0);
1116                                }
1117                                ios.width(25);
1118                                internal(ios);
1119                                {
1120                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1121                                    std::string ex(str, iter.base());
1122                                    assert(ex == "+***********************0");
1123                                    assert(ios.width() == 0);
1124                                }
1125                            }
1126                            ios.imbue(lg);
1127                            {
1128                                ios.width(0);
1129                                {
1130                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1131                                    std::string ex(str, iter.base());
1132                                    assert(ex == "+0");
1133                                    assert(ios.width() == 0);
1134                                }
1135                                ios.width(25);
1136                                left(ios);
1137                                {
1138                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1139                                    std::string ex(str, iter.base());
1140                                    assert(ex == "+0***********************");
1141                                    assert(ios.width() == 0);
1142                                }
1143                                ios.width(25);
1144                                right(ios);
1145                                {
1146                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1147                                    std::string ex(str, iter.base());
1148                                    assert(ex == "***********************+0");
1149                                    assert(ios.width() == 0);
1150                                }
1151                                ios.width(25);
1152                                internal(ios);
1153                                {
1154                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1155                                    std::string ex(str, iter.base());
1156                                    assert(ex == "+***********************0");
1157                                    assert(ios.width() == 0);
1158                                }
1159                            }
1160                        }
1161                        showpoint(ios);
1162                        {
1163                            ios.imbue(lc);
1164                            {
1165                                ios.width(0);
1166                                {
1167                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1168                                    std::string ex(str, iter.base());
1169                                    assert(ex == "+0.");
1170                                    assert(ios.width() == 0);
1171                                }
1172                                ios.width(25);
1173                                left(ios);
1174                                {
1175                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1176                                    std::string ex(str, iter.base());
1177                                    assert(ex == "+0.**********************");
1178                                    assert(ios.width() == 0);
1179                                }
1180                                ios.width(25);
1181                                right(ios);
1182                                {
1183                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1184                                    std::string ex(str, iter.base());
1185                                    assert(ex == "**********************+0.");
1186                                    assert(ios.width() == 0);
1187                                }
1188                                ios.width(25);
1189                                internal(ios);
1190                                {
1191                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1192                                    std::string ex(str, iter.base());
1193                                    assert(ex == "+**********************0.");
1194                                    assert(ios.width() == 0);
1195                                }
1196                            }
1197                            ios.imbue(lg);
1198                            {
1199                                ios.width(0);
1200                                {
1201                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1202                                    std::string ex(str, iter.base());
1203                                    assert(ex == "+0;");
1204                                    assert(ios.width() == 0);
1205                                }
1206                                ios.width(25);
1207                                left(ios);
1208                                {
1209                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1210                                    std::string ex(str, iter.base());
1211                                    assert(ex == "+0;**********************");
1212                                    assert(ios.width() == 0);
1213                                }
1214                                ios.width(25);
1215                                right(ios);
1216                                {
1217                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1218                                    std::string ex(str, iter.base());
1219                                    assert(ex == "**********************+0;");
1220                                    assert(ios.width() == 0);
1221                                }
1222                                ios.width(25);
1223                                internal(ios);
1224                                {
1225                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1226                                    std::string ex(str, iter.base());
1227                                    assert(ex == "+**********************0;");
1228                                    assert(ios.width() == 0);
1229                                }
1230                            }
1231                        }
1232                    }
1233                }
1234            }
1235            ios.precision(6);
1236            {
1237                nouppercase(ios);
1238                {
1239                    noshowpos(ios);
1240                    {
1241                        noshowpoint(ios);
1242                        {
1243                            ios.imbue(lc);
1244                            {
1245                                ios.width(0);
1246                                {
1247                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1248                                    std::string ex(str, iter.base());
1249                                    assert(ex == "0");
1250                                    assert(ios.width() == 0);
1251                                }
1252                                ios.width(25);
1253                                left(ios);
1254                                {
1255                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1256                                    std::string ex(str, iter.base());
1257                                    assert(ex == "0************************");
1258                                    assert(ios.width() == 0);
1259                                }
1260                                ios.width(25);
1261                                right(ios);
1262                                {
1263                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1264                                    std::string ex(str, iter.base());
1265                                    assert(ex == "************************0");
1266                                    assert(ios.width() == 0);
1267                                }
1268                                ios.width(25);
1269                                internal(ios);
1270                                {
1271                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1272                                    std::string ex(str, iter.base());
1273                                    assert(ex == "************************0");
1274                                    assert(ios.width() == 0);
1275                                }
1276                            }
1277                            ios.imbue(lg);
1278                            {
1279                                ios.width(0);
1280                                {
1281                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1282                                    std::string ex(str, iter.base());
1283                                    assert(ex == "0");
1284                                    assert(ios.width() == 0);
1285                                }
1286                                ios.width(25);
1287                                left(ios);
1288                                {
1289                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1290                                    std::string ex(str, iter.base());
1291                                    assert(ex == "0************************");
1292                                    assert(ios.width() == 0);
1293                                }
1294                                ios.width(25);
1295                                right(ios);
1296                                {
1297                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1298                                    std::string ex(str, iter.base());
1299                                    assert(ex == "************************0");
1300                                    assert(ios.width() == 0);
1301                                }
1302                                ios.width(25);
1303                                internal(ios);
1304                                {
1305                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1306                                    std::string ex(str, iter.base());
1307                                    assert(ex == "************************0");
1308                                    assert(ios.width() == 0);
1309                                }
1310                            }
1311                        }
1312                        showpoint(ios);
1313                        {
1314                            ios.imbue(lc);
1315                            {
1316                                ios.width(0);
1317                                {
1318                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1319                                    std::string ex(str, iter.base());
1320                                    assert(ex == "0.00000");
1321                                    assert(ios.width() == 0);
1322                                }
1323                                ios.width(25);
1324                                left(ios);
1325                                {
1326                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1327                                    std::string ex(str, iter.base());
1328                                    assert(ex == "0.00000******************");
1329                                    assert(ios.width() == 0);
1330                                }
1331                                ios.width(25);
1332                                right(ios);
1333                                {
1334                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1335                                    std::string ex(str, iter.base());
1336                                    assert(ex == "******************0.00000");
1337                                    assert(ios.width() == 0);
1338                                }
1339                                ios.width(25);
1340                                internal(ios);
1341                                {
1342                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1343                                    std::string ex(str, iter.base());
1344                                    assert(ex == "******************0.00000");
1345                                    assert(ios.width() == 0);
1346                                }
1347                            }
1348                            ios.imbue(lg);
1349                            {
1350                                ios.width(0);
1351                                {
1352                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1353                                    std::string ex(str, iter.base());
1354                                    assert(ex == "0;00000");
1355                                    assert(ios.width() == 0);
1356                                }
1357                                ios.width(25);
1358                                left(ios);
1359                                {
1360                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1361                                    std::string ex(str, iter.base());
1362                                    assert(ex == "0;00000******************");
1363                                    assert(ios.width() == 0);
1364                                }
1365                                ios.width(25);
1366                                right(ios);
1367                                {
1368                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1369                                    std::string ex(str, iter.base());
1370                                    assert(ex == "******************0;00000");
1371                                    assert(ios.width() == 0);
1372                                }
1373                                ios.width(25);
1374                                internal(ios);
1375                                {
1376                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1377                                    std::string ex(str, iter.base());
1378                                    assert(ex == "******************0;00000");
1379                                    assert(ios.width() == 0);
1380                                }
1381                            }
1382                        }
1383                    }
1384                    showpos(ios);
1385                    {
1386                        noshowpoint(ios);
1387                        {
1388                            ios.imbue(lc);
1389                            {
1390                                ios.width(0);
1391                                {
1392                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1393                                    std::string ex(str, iter.base());
1394                                    assert(ex == "+0");
1395                                    assert(ios.width() == 0);
1396                                }
1397                                ios.width(25);
1398                                left(ios);
1399                                {
1400                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1401                                    std::string ex(str, iter.base());
1402                                    assert(ex == "+0***********************");
1403                                    assert(ios.width() == 0);
1404                                }
1405                                ios.width(25);
1406                                right(ios);
1407                                {
1408                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1409                                    std::string ex(str, iter.base());
1410                                    assert(ex == "***********************+0");
1411                                    assert(ios.width() == 0);
1412                                }
1413                                ios.width(25);
1414                                internal(ios);
1415                                {
1416                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1417                                    std::string ex(str, iter.base());
1418                                    assert(ex == "+***********************0");
1419                                    assert(ios.width() == 0);
1420                                }
1421                            }
1422                            ios.imbue(lg);
1423                            {
1424                                ios.width(0);
1425                                {
1426                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1427                                    std::string ex(str, iter.base());
1428                                    assert(ex == "+0");
1429                                    assert(ios.width() == 0);
1430                                }
1431                                ios.width(25);
1432                                left(ios);
1433                                {
1434                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1435                                    std::string ex(str, iter.base());
1436                                    assert(ex == "+0***********************");
1437                                    assert(ios.width() == 0);
1438                                }
1439                                ios.width(25);
1440                                right(ios);
1441                                {
1442                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1443                                    std::string ex(str, iter.base());
1444                                    assert(ex == "***********************+0");
1445                                    assert(ios.width() == 0);
1446                                }
1447                                ios.width(25);
1448                                internal(ios);
1449                                {
1450                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1451                                    std::string ex(str, iter.base());
1452                                    assert(ex == "+***********************0");
1453                                    assert(ios.width() == 0);
1454                                }
1455                            }
1456                        }
1457                        showpoint(ios);
1458                        {
1459                            ios.imbue(lc);
1460                            {
1461                                ios.width(0);
1462                                {
1463                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1464                                    std::string ex(str, iter.base());
1465                                    assert(ex == "+0.00000");
1466                                    assert(ios.width() == 0);
1467                                }
1468                                ios.width(25);
1469                                left(ios);
1470                                {
1471                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1472                                    std::string ex(str, iter.base());
1473                                    assert(ex == "+0.00000*****************");
1474                                    assert(ios.width() == 0);
1475                                }
1476                                ios.width(25);
1477                                right(ios);
1478                                {
1479                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1480                                    std::string ex(str, iter.base());
1481                                    assert(ex == "*****************+0.00000");
1482                                    assert(ios.width() == 0);
1483                                }
1484                                ios.width(25);
1485                                internal(ios);
1486                                {
1487                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1488                                    std::string ex(str, iter.base());
1489                                    assert(ex == "+*****************0.00000");
1490                                    assert(ios.width() == 0);
1491                                }
1492                            }
1493                            ios.imbue(lg);
1494                            {
1495                                ios.width(0);
1496                                {
1497                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1498                                    std::string ex(str, iter.base());
1499                                    assert(ex == "+0;00000");
1500                                    assert(ios.width() == 0);
1501                                }
1502                                ios.width(25);
1503                                left(ios);
1504                                {
1505                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1506                                    std::string ex(str, iter.base());
1507                                    assert(ex == "+0;00000*****************");
1508                                    assert(ios.width() == 0);
1509                                }
1510                                ios.width(25);
1511                                right(ios);
1512                                {
1513                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1514                                    std::string ex(str, iter.base());
1515                                    assert(ex == "*****************+0;00000");
1516                                    assert(ios.width() == 0);
1517                                }
1518                                ios.width(25);
1519                                internal(ios);
1520                                {
1521                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1522                                    std::string ex(str, iter.base());
1523                                    assert(ex == "+*****************0;00000");
1524                                    assert(ios.width() == 0);
1525                                }
1526                            }
1527                        }
1528                    }
1529                }
1530                uppercase(ios);
1531                {
1532                    noshowpos(ios);
1533                    {
1534                        noshowpoint(ios);
1535                        {
1536                            ios.imbue(lc);
1537                            {
1538                                ios.width(0);
1539                                {
1540                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1541                                    std::string ex(str, iter.base());
1542                                    assert(ex == "0");
1543                                    assert(ios.width() == 0);
1544                                }
1545                                ios.width(25);
1546                                left(ios);
1547                                {
1548                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1549                                    std::string ex(str, iter.base());
1550                                    assert(ex == "0************************");
1551                                    assert(ios.width() == 0);
1552                                }
1553                                ios.width(25);
1554                                right(ios);
1555                                {
1556                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1557                                    std::string ex(str, iter.base());
1558                                    assert(ex == "************************0");
1559                                    assert(ios.width() == 0);
1560                                }
1561                                ios.width(25);
1562                                internal(ios);
1563                                {
1564                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1565                                    std::string ex(str, iter.base());
1566                                    assert(ex == "************************0");
1567                                    assert(ios.width() == 0);
1568                                }
1569                            }
1570                            ios.imbue(lg);
1571                            {
1572                                ios.width(0);
1573                                {
1574                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1575                                    std::string ex(str, iter.base());
1576                                    assert(ex == "0");
1577                                    assert(ios.width() == 0);
1578                                }
1579                                ios.width(25);
1580                                left(ios);
1581                                {
1582                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1583                                    std::string ex(str, iter.base());
1584                                    assert(ex == "0************************");
1585                                    assert(ios.width() == 0);
1586                                }
1587                                ios.width(25);
1588                                right(ios);
1589                                {
1590                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1591                                    std::string ex(str, iter.base());
1592                                    assert(ex == "************************0");
1593                                    assert(ios.width() == 0);
1594                                }
1595                                ios.width(25);
1596                                internal(ios);
1597                                {
1598                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1599                                    std::string ex(str, iter.base());
1600                                    assert(ex == "************************0");
1601                                    assert(ios.width() == 0);
1602                                }
1603                            }
1604                        }
1605                        showpoint(ios);
1606                        {
1607                            ios.imbue(lc);
1608                            {
1609                                ios.width(0);
1610                                {
1611                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1612                                    std::string ex(str, iter.base());
1613                                    assert(ex == "0.00000");
1614                                    assert(ios.width() == 0);
1615                                }
1616                                ios.width(25);
1617                                left(ios);
1618                                {
1619                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1620                                    std::string ex(str, iter.base());
1621                                    assert(ex == "0.00000******************");
1622                                    assert(ios.width() == 0);
1623                                }
1624                                ios.width(25);
1625                                right(ios);
1626                                {
1627                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1628                                    std::string ex(str, iter.base());
1629                                    assert(ex == "******************0.00000");
1630                                    assert(ios.width() == 0);
1631                                }
1632                                ios.width(25);
1633                                internal(ios);
1634                                {
1635                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1636                                    std::string ex(str, iter.base());
1637                                    assert(ex == "******************0.00000");
1638                                    assert(ios.width() == 0);
1639                                }
1640                            }
1641                            ios.imbue(lg);
1642                            {
1643                                ios.width(0);
1644                                {
1645                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1646                                    std::string ex(str, iter.base());
1647                                    assert(ex == "0;00000");
1648                                    assert(ios.width() == 0);
1649                                }
1650                                ios.width(25);
1651                                left(ios);
1652                                {
1653                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1654                                    std::string ex(str, iter.base());
1655                                    assert(ex == "0;00000******************");
1656                                    assert(ios.width() == 0);
1657                                }
1658                                ios.width(25);
1659                                right(ios);
1660                                {
1661                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1662                                    std::string ex(str, iter.base());
1663                                    assert(ex == "******************0;00000");
1664                                    assert(ios.width() == 0);
1665                                }
1666                                ios.width(25);
1667                                internal(ios);
1668                                {
1669                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1670                                    std::string ex(str, iter.base());
1671                                    assert(ex == "******************0;00000");
1672                                    assert(ios.width() == 0);
1673                                }
1674                            }
1675                        }
1676                    }
1677                    showpos(ios);
1678                    {
1679                        noshowpoint(ios);
1680                        {
1681                            ios.imbue(lc);
1682                            {
1683                                ios.width(0);
1684                                {
1685                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1686                                    std::string ex(str, iter.base());
1687                                    assert(ex == "+0");
1688                                    assert(ios.width() == 0);
1689                                }
1690                                ios.width(25);
1691                                left(ios);
1692                                {
1693                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1694                                    std::string ex(str, iter.base());
1695                                    assert(ex == "+0***********************");
1696                                    assert(ios.width() == 0);
1697                                }
1698                                ios.width(25);
1699                                right(ios);
1700                                {
1701                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1702                                    std::string ex(str, iter.base());
1703                                    assert(ex == "***********************+0");
1704                                    assert(ios.width() == 0);
1705                                }
1706                                ios.width(25);
1707                                internal(ios);
1708                                {
1709                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1710                                    std::string ex(str, iter.base());
1711                                    assert(ex == "+***********************0");
1712                                    assert(ios.width() == 0);
1713                                }
1714                            }
1715                            ios.imbue(lg);
1716                            {
1717                                ios.width(0);
1718                                {
1719                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1720                                    std::string ex(str, iter.base());
1721                                    assert(ex == "+0");
1722                                    assert(ios.width() == 0);
1723                                }
1724                                ios.width(25);
1725                                left(ios);
1726                                {
1727                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1728                                    std::string ex(str, iter.base());
1729                                    assert(ex == "+0***********************");
1730                                    assert(ios.width() == 0);
1731                                }
1732                                ios.width(25);
1733                                right(ios);
1734                                {
1735                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1736                                    std::string ex(str, iter.base());
1737                                    assert(ex == "***********************+0");
1738                                    assert(ios.width() == 0);
1739                                }
1740                                ios.width(25);
1741                                internal(ios);
1742                                {
1743                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1744                                    std::string ex(str, iter.base());
1745                                    assert(ex == "+***********************0");
1746                                    assert(ios.width() == 0);
1747                                }
1748                            }
1749                        }
1750                        showpoint(ios);
1751                        {
1752                            ios.imbue(lc);
1753                            {
1754                                ios.width(0);
1755                                {
1756                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1757                                    std::string ex(str, iter.base());
1758                                    assert(ex == "+0.00000");
1759                                    assert(ios.width() == 0);
1760                                }
1761                                ios.width(25);
1762                                left(ios);
1763                                {
1764                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1765                                    std::string ex(str, iter.base());
1766                                    assert(ex == "+0.00000*****************");
1767                                    assert(ios.width() == 0);
1768                                }
1769                                ios.width(25);
1770                                right(ios);
1771                                {
1772                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1773                                    std::string ex(str, iter.base());
1774                                    assert(ex == "*****************+0.00000");
1775                                    assert(ios.width() == 0);
1776                                }
1777                                ios.width(25);
1778                                internal(ios);
1779                                {
1780                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1781                                    std::string ex(str, iter.base());
1782                                    assert(ex == "+*****************0.00000");
1783                                    assert(ios.width() == 0);
1784                                }
1785                            }
1786                            ios.imbue(lg);
1787                            {
1788                                ios.width(0);
1789                                {
1790                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1791                                    std::string ex(str, iter.base());
1792                                    assert(ex == "+0;00000");
1793                                    assert(ios.width() == 0);
1794                                }
1795                                ios.width(25);
1796                                left(ios);
1797                                {
1798                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1799                                    std::string ex(str, iter.base());
1800                                    assert(ex == "+0;00000*****************");
1801                                    assert(ios.width() == 0);
1802                                }
1803                                ios.width(25);
1804                                right(ios);
1805                                {
1806                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1807                                    std::string ex(str, iter.base());
1808                                    assert(ex == "*****************+0;00000");
1809                                    assert(ios.width() == 0);
1810                                }
1811                                ios.width(25);
1812                                internal(ios);
1813                                {
1814                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1815                                    std::string ex(str, iter.base());
1816                                    assert(ex == "+*****************0;00000");
1817                                    assert(ios.width() == 0);
1818                                }
1819                            }
1820                        }
1821                    }
1822                }
1823            }
1824            ios.precision(16);
1825            {
1826                nouppercase(ios);
1827                {
1828                    noshowpos(ios);
1829                    {
1830                        noshowpoint(ios);
1831                        {
1832                            ios.imbue(lc);
1833                            {
1834                                ios.width(0);
1835                                {
1836                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1837                                    std::string ex(str, iter.base());
1838                                    assert(ex == "0");
1839                                    assert(ios.width() == 0);
1840                                }
1841                                ios.width(25);
1842                                left(ios);
1843                                {
1844                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1845                                    std::string ex(str, iter.base());
1846                                    assert(ex == "0************************");
1847                                    assert(ios.width() == 0);
1848                                }
1849                                ios.width(25);
1850                                right(ios);
1851                                {
1852                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1853                                    std::string ex(str, iter.base());
1854                                    assert(ex == "************************0");
1855                                    assert(ios.width() == 0);
1856                                }
1857                                ios.width(25);
1858                                internal(ios);
1859                                {
1860                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1861                                    std::string ex(str, iter.base());
1862                                    assert(ex == "************************0");
1863                                    assert(ios.width() == 0);
1864                                }
1865                            }
1866                            ios.imbue(lg);
1867                            {
1868                                ios.width(0);
1869                                {
1870                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1871                                    std::string ex(str, iter.base());
1872                                    assert(ex == "0");
1873                                    assert(ios.width() == 0);
1874                                }
1875                                ios.width(25);
1876                                left(ios);
1877                                {
1878                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1879                                    std::string ex(str, iter.base());
1880                                    assert(ex == "0************************");
1881                                    assert(ios.width() == 0);
1882                                }
1883                                ios.width(25);
1884                                right(ios);
1885                                {
1886                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1887                                    std::string ex(str, iter.base());
1888                                    assert(ex == "************************0");
1889                                    assert(ios.width() == 0);
1890                                }
1891                                ios.width(25);
1892                                internal(ios);
1893                                {
1894                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1895                                    std::string ex(str, iter.base());
1896                                    assert(ex == "************************0");
1897                                    assert(ios.width() == 0);
1898                                }
1899                            }
1900                        }
1901                        showpoint(ios);
1902                        {
1903                            ios.imbue(lc);
1904                            {
1905                                ios.width(0);
1906                                {
1907                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1908                                    std::string ex(str, iter.base());
1909                                    assert(ex == "0.000000000000000");
1910                                    assert(ios.width() == 0);
1911                                }
1912                                ios.width(25);
1913                                left(ios);
1914                                {
1915                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1916                                    std::string ex(str, iter.base());
1917                                    assert(ex == "0.000000000000000********");
1918                                    assert(ios.width() == 0);
1919                                }
1920                                ios.width(25);
1921                                right(ios);
1922                                {
1923                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1924                                    std::string ex(str, iter.base());
1925                                    assert(ex == "********0.000000000000000");
1926                                    assert(ios.width() == 0);
1927                                }
1928                                ios.width(25);
1929                                internal(ios);
1930                                {
1931                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1932                                    std::string ex(str, iter.base());
1933                                    assert(ex == "********0.000000000000000");
1934                                    assert(ios.width() == 0);
1935                                }
1936                            }
1937                            ios.imbue(lg);
1938                            {
1939                                ios.width(0);
1940                                {
1941                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1942                                    std::string ex(str, iter.base());
1943                                    assert(ex == "0;000000000000000");
1944                                    assert(ios.width() == 0);
1945                                }
1946                                ios.width(25);
1947                                left(ios);
1948                                {
1949                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1950                                    std::string ex(str, iter.base());
1951                                    assert(ex == "0;000000000000000********");
1952                                    assert(ios.width() == 0);
1953                                }
1954                                ios.width(25);
1955                                right(ios);
1956                                {
1957                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1958                                    std::string ex(str, iter.base());
1959                                    assert(ex == "********0;000000000000000");
1960                                    assert(ios.width() == 0);
1961                                }
1962                                ios.width(25);
1963                                internal(ios);
1964                                {
1965                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1966                                    std::string ex(str, iter.base());
1967                                    assert(ex == "********0;000000000000000");
1968                                    assert(ios.width() == 0);
1969                                }
1970                            }
1971                        }
1972                    }
1973                    showpos(ios);
1974                    {
1975                        noshowpoint(ios);
1976                        {
1977                            ios.imbue(lc);
1978                            {
1979                                ios.width(0);
1980                                {
1981                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1982                                    std::string ex(str, iter.base());
1983                                    assert(ex == "+0");
1984                                    assert(ios.width() == 0);
1985                                }
1986                                ios.width(25);
1987                                left(ios);
1988                                {
1989                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1990                                    std::string ex(str, iter.base());
1991                                    assert(ex == "+0***********************");
1992                                    assert(ios.width() == 0);
1993                                }
1994                                ios.width(25);
1995                                right(ios);
1996                                {
1997                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
1998                                    std::string ex(str, iter.base());
1999                                    assert(ex == "***********************+0");
2000                                    assert(ios.width() == 0);
2001                                }
2002                                ios.width(25);
2003                                internal(ios);
2004                                {
2005                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2006                                    std::string ex(str, iter.base());
2007                                    assert(ex == "+***********************0");
2008                                    assert(ios.width() == 0);
2009                                }
2010                            }
2011                            ios.imbue(lg);
2012                            {
2013                                ios.width(0);
2014                                {
2015                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2016                                    std::string ex(str, iter.base());
2017                                    assert(ex == "+0");
2018                                    assert(ios.width() == 0);
2019                                }
2020                                ios.width(25);
2021                                left(ios);
2022                                {
2023                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2024                                    std::string ex(str, iter.base());
2025                                    assert(ex == "+0***********************");
2026                                    assert(ios.width() == 0);
2027                                }
2028                                ios.width(25);
2029                                right(ios);
2030                                {
2031                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2032                                    std::string ex(str, iter.base());
2033                                    assert(ex == "***********************+0");
2034                                    assert(ios.width() == 0);
2035                                }
2036                                ios.width(25);
2037                                internal(ios);
2038                                {
2039                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2040                                    std::string ex(str, iter.base());
2041                                    assert(ex == "+***********************0");
2042                                    assert(ios.width() == 0);
2043                                }
2044                            }
2045                        }
2046                        showpoint(ios);
2047                        {
2048                            ios.imbue(lc);
2049                            {
2050                                ios.width(0);
2051                                {
2052                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2053                                    std::string ex(str, iter.base());
2054                                    assert(ex == "+0.000000000000000");
2055                                    assert(ios.width() == 0);
2056                                }
2057                                ios.width(25);
2058                                left(ios);
2059                                {
2060                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2061                                    std::string ex(str, iter.base());
2062                                    assert(ex == "+0.000000000000000*******");
2063                                    assert(ios.width() == 0);
2064                                }
2065                                ios.width(25);
2066                                right(ios);
2067                                {
2068                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2069                                    std::string ex(str, iter.base());
2070                                    assert(ex == "*******+0.000000000000000");
2071                                    assert(ios.width() == 0);
2072                                }
2073                                ios.width(25);
2074                                internal(ios);
2075                                {
2076                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2077                                    std::string ex(str, iter.base());
2078                                    assert(ex == "+*******0.000000000000000");
2079                                    assert(ios.width() == 0);
2080                                }
2081                            }
2082                            ios.imbue(lg);
2083                            {
2084                                ios.width(0);
2085                                {
2086                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2087                                    std::string ex(str, iter.base());
2088                                    assert(ex == "+0;000000000000000");
2089                                    assert(ios.width() == 0);
2090                                }
2091                                ios.width(25);
2092                                left(ios);
2093                                {
2094                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2095                                    std::string ex(str, iter.base());
2096                                    assert(ex == "+0;000000000000000*******");
2097                                    assert(ios.width() == 0);
2098                                }
2099                                ios.width(25);
2100                                right(ios);
2101                                {
2102                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2103                                    std::string ex(str, iter.base());
2104                                    assert(ex == "*******+0;000000000000000");
2105                                    assert(ios.width() == 0);
2106                                }
2107                                ios.width(25);
2108                                internal(ios);
2109                                {
2110                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2111                                    std::string ex(str, iter.base());
2112                                    assert(ex == "+*******0;000000000000000");
2113                                    assert(ios.width() == 0);
2114                                }
2115                            }
2116                        }
2117                    }
2118                }
2119                uppercase(ios);
2120                {
2121                    noshowpos(ios);
2122                    {
2123                        noshowpoint(ios);
2124                        {
2125                            ios.imbue(lc);
2126                            {
2127                                ios.width(0);
2128                                {
2129                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2130                                    std::string ex(str, iter.base());
2131                                    assert(ex == "0");
2132                                    assert(ios.width() == 0);
2133                                }
2134                                ios.width(25);
2135                                left(ios);
2136                                {
2137                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2138                                    std::string ex(str, iter.base());
2139                                    assert(ex == "0************************");
2140                                    assert(ios.width() == 0);
2141                                }
2142                                ios.width(25);
2143                                right(ios);
2144                                {
2145                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2146                                    std::string ex(str, iter.base());
2147                                    assert(ex == "************************0");
2148                                    assert(ios.width() == 0);
2149                                }
2150                                ios.width(25);
2151                                internal(ios);
2152                                {
2153                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2154                                    std::string ex(str, iter.base());
2155                                    assert(ex == "************************0");
2156                                    assert(ios.width() == 0);
2157                                }
2158                            }
2159                            ios.imbue(lg);
2160                            {
2161                                ios.width(0);
2162                                {
2163                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2164                                    std::string ex(str, iter.base());
2165                                    assert(ex == "0");
2166                                    assert(ios.width() == 0);
2167                                }
2168                                ios.width(25);
2169                                left(ios);
2170                                {
2171                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2172                                    std::string ex(str, iter.base());
2173                                    assert(ex == "0************************");
2174                                    assert(ios.width() == 0);
2175                                }
2176                                ios.width(25);
2177                                right(ios);
2178                                {
2179                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2180                                    std::string ex(str, iter.base());
2181                                    assert(ex == "************************0");
2182                                    assert(ios.width() == 0);
2183                                }
2184                                ios.width(25);
2185                                internal(ios);
2186                                {
2187                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2188                                    std::string ex(str, iter.base());
2189                                    assert(ex == "************************0");
2190                                    assert(ios.width() == 0);
2191                                }
2192                            }
2193                        }
2194                        showpoint(ios);
2195                        {
2196                            ios.imbue(lc);
2197                            {
2198                                ios.width(0);
2199                                {
2200                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2201                                    std::string ex(str, iter.base());
2202                                    assert(ex == "0.000000000000000");
2203                                    assert(ios.width() == 0);
2204                                }
2205                                ios.width(25);
2206                                left(ios);
2207                                {
2208                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2209                                    std::string ex(str, iter.base());
2210                                    assert(ex == "0.000000000000000********");
2211                                    assert(ios.width() == 0);
2212                                }
2213                                ios.width(25);
2214                                right(ios);
2215                                {
2216                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2217                                    std::string ex(str, iter.base());
2218                                    assert(ex == "********0.000000000000000");
2219                                    assert(ios.width() == 0);
2220                                }
2221                                ios.width(25);
2222                                internal(ios);
2223                                {
2224                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2225                                    std::string ex(str, iter.base());
2226                                    assert(ex == "********0.000000000000000");
2227                                    assert(ios.width() == 0);
2228                                }
2229                            }
2230                            ios.imbue(lg);
2231                            {
2232                                ios.width(0);
2233                                {
2234                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2235                                    std::string ex(str, iter.base());
2236                                    assert(ex == "0;000000000000000");
2237                                    assert(ios.width() == 0);
2238                                }
2239                                ios.width(25);
2240                                left(ios);
2241                                {
2242                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2243                                    std::string ex(str, iter.base());
2244                                    assert(ex == "0;000000000000000********");
2245                                    assert(ios.width() == 0);
2246                                }
2247                                ios.width(25);
2248                                right(ios);
2249                                {
2250                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2251                                    std::string ex(str, iter.base());
2252                                    assert(ex == "********0;000000000000000");
2253                                    assert(ios.width() == 0);
2254                                }
2255                                ios.width(25);
2256                                internal(ios);
2257                                {
2258                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2259                                    std::string ex(str, iter.base());
2260                                    assert(ex == "********0;000000000000000");
2261                                    assert(ios.width() == 0);
2262                                }
2263                            }
2264                        }
2265                    }
2266                    showpos(ios);
2267                    {
2268                        noshowpoint(ios);
2269                        {
2270                            ios.imbue(lc);
2271                            {
2272                                ios.width(0);
2273                                {
2274                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2275                                    std::string ex(str, iter.base());
2276                                    assert(ex == "+0");
2277                                    assert(ios.width() == 0);
2278                                }
2279                                ios.width(25);
2280                                left(ios);
2281                                {
2282                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2283                                    std::string ex(str, iter.base());
2284                                    assert(ex == "+0***********************");
2285                                    assert(ios.width() == 0);
2286                                }
2287                                ios.width(25);
2288                                right(ios);
2289                                {
2290                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2291                                    std::string ex(str, iter.base());
2292                                    assert(ex == "***********************+0");
2293                                    assert(ios.width() == 0);
2294                                }
2295                                ios.width(25);
2296                                internal(ios);
2297                                {
2298                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2299                                    std::string ex(str, iter.base());
2300                                    assert(ex == "+***********************0");
2301                                    assert(ios.width() == 0);
2302                                }
2303                            }
2304                            ios.imbue(lg);
2305                            {
2306                                ios.width(0);
2307                                {
2308                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2309                                    std::string ex(str, iter.base());
2310                                    assert(ex == "+0");
2311                                    assert(ios.width() == 0);
2312                                }
2313                                ios.width(25);
2314                                left(ios);
2315                                {
2316                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2317                                    std::string ex(str, iter.base());
2318                                    assert(ex == "+0***********************");
2319                                    assert(ios.width() == 0);
2320                                }
2321                                ios.width(25);
2322                                right(ios);
2323                                {
2324                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2325                                    std::string ex(str, iter.base());
2326                                    assert(ex == "***********************+0");
2327                                    assert(ios.width() == 0);
2328                                }
2329                                ios.width(25);
2330                                internal(ios);
2331                                {
2332                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2333                                    std::string ex(str, iter.base());
2334                                    assert(ex == "+***********************0");
2335                                    assert(ios.width() == 0);
2336                                }
2337                            }
2338                        }
2339                        showpoint(ios);
2340                        {
2341                            ios.imbue(lc);
2342                            {
2343                                ios.width(0);
2344                                {
2345                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2346                                    std::string ex(str, iter.base());
2347                                    assert(ex == "+0.000000000000000");
2348                                    assert(ios.width() == 0);
2349                                }
2350                                ios.width(25);
2351                                left(ios);
2352                                {
2353                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2354                                    std::string ex(str, iter.base());
2355                                    assert(ex == "+0.000000000000000*******");
2356                                    assert(ios.width() == 0);
2357                                }
2358                                ios.width(25);
2359                                right(ios);
2360                                {
2361                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2362                                    std::string ex(str, iter.base());
2363                                    assert(ex == "*******+0.000000000000000");
2364                                    assert(ios.width() == 0);
2365                                }
2366                                ios.width(25);
2367                                internal(ios);
2368                                {
2369                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2370                                    std::string ex(str, iter.base());
2371                                    assert(ex == "+*******0.000000000000000");
2372                                    assert(ios.width() == 0);
2373                                }
2374                            }
2375                            ios.imbue(lg);
2376                            {
2377                                ios.width(0);
2378                                {
2379                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2380                                    std::string ex(str, iter.base());
2381                                    assert(ex == "+0;000000000000000");
2382                                    assert(ios.width() == 0);
2383                                }
2384                                ios.width(25);
2385                                left(ios);
2386                                {
2387                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2388                                    std::string ex(str, iter.base());
2389                                    assert(ex == "+0;000000000000000*******");
2390                                    assert(ios.width() == 0);
2391                                }
2392                                ios.width(25);
2393                                right(ios);
2394                                {
2395                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2396                                    std::string ex(str, iter.base());
2397                                    assert(ex == "*******+0;000000000000000");
2398                                    assert(ios.width() == 0);
2399                                }
2400                                ios.width(25);
2401                                internal(ios);
2402                                {
2403                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2404                                    std::string ex(str, iter.base());
2405                                    assert(ex == "+*******0;000000000000000");
2406                                    assert(ios.width() == 0);
2407                                }
2408                            }
2409                        }
2410                    }
2411                }
2412            }
2413            ios.precision(60);
2414            {
2415                nouppercase(ios);
2416                {
2417                    noshowpos(ios);
2418                    {
2419                        noshowpoint(ios);
2420                        {
2421                            ios.imbue(lc);
2422                            {
2423                                ios.width(0);
2424                                {
2425                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2426                                    std::string ex(str, iter.base());
2427                                    assert(ex == "0");
2428                                    assert(ios.width() == 0);
2429                                }
2430                                ios.width(25);
2431                                left(ios);
2432                                {
2433                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2434                                    std::string ex(str, iter.base());
2435                                    assert(ex == "0************************");
2436                                    assert(ios.width() == 0);
2437                                }
2438                                ios.width(25);
2439                                right(ios);
2440                                {
2441                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2442                                    std::string ex(str, iter.base());
2443                                    assert(ex == "************************0");
2444                                    assert(ios.width() == 0);
2445                                }
2446                                ios.width(25);
2447                                internal(ios);
2448                                {
2449                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2450                                    std::string ex(str, iter.base());
2451                                    assert(ex == "************************0");
2452                                    assert(ios.width() == 0);
2453                                }
2454                            }
2455                            ios.imbue(lg);
2456                            {
2457                                ios.width(0);
2458                                {
2459                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2460                                    std::string ex(str, iter.base());
2461                                    assert(ex == "0");
2462                                    assert(ios.width() == 0);
2463                                }
2464                                ios.width(25);
2465                                left(ios);
2466                                {
2467                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2468                                    std::string ex(str, iter.base());
2469                                    assert(ex == "0************************");
2470                                    assert(ios.width() == 0);
2471                                }
2472                                ios.width(25);
2473                                right(ios);
2474                                {
2475                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2476                                    std::string ex(str, iter.base());
2477                                    assert(ex == "************************0");
2478                                    assert(ios.width() == 0);
2479                                }
2480                                ios.width(25);
2481                                internal(ios);
2482                                {
2483                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2484                                    std::string ex(str, iter.base());
2485                                    assert(ex == "************************0");
2486                                    assert(ios.width() == 0);
2487                                }
2488                            }
2489                        }
2490                        showpoint(ios);
2491                        {
2492                            ios.imbue(lc);
2493                            {
2494                                ios.width(0);
2495                                {
2496                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2497                                    std::string ex(str, iter.base());
2498                                    assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2499                                    assert(ios.width() == 0);
2500                                }
2501                                ios.width(25);
2502                                left(ios);
2503                                {
2504                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2505                                    std::string ex(str, iter.base());
2506                                    assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2507                                    assert(ios.width() == 0);
2508                                }
2509                                ios.width(25);
2510                                right(ios);
2511                                {
2512                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2513                                    std::string ex(str, iter.base());
2514                                    assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2515                                    assert(ios.width() == 0);
2516                                }
2517                                ios.width(25);
2518                                internal(ios);
2519                                {
2520                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2521                                    std::string ex(str, iter.base());
2522                                    assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2523                                    assert(ios.width() == 0);
2524                                }
2525                            }
2526                            ios.imbue(lg);
2527                            {
2528                                ios.width(0);
2529                                {
2530                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2531                                    std::string ex(str, iter.base());
2532                                    assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2533                                    assert(ios.width() == 0);
2534                                }
2535                                ios.width(25);
2536                                left(ios);
2537                                {
2538                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2539                                    std::string ex(str, iter.base());
2540                                    assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2541                                    assert(ios.width() == 0);
2542                                }
2543                                ios.width(25);
2544                                right(ios);
2545                                {
2546                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2547                                    std::string ex(str, iter.base());
2548                                    assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2549                                    assert(ios.width() == 0);
2550                                }
2551                                ios.width(25);
2552                                internal(ios);
2553                                {
2554                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2555                                    std::string ex(str, iter.base());
2556                                    assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2557                                    assert(ios.width() == 0);
2558                                }
2559                            }
2560                        }
2561                    }
2562                    showpos(ios);
2563                    {
2564                        noshowpoint(ios);
2565                        {
2566                            ios.imbue(lc);
2567                            {
2568                                ios.width(0);
2569                                {
2570                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2571                                    std::string ex(str, iter.base());
2572                                    assert(ex == "+0");
2573                                    assert(ios.width() == 0);
2574                                }
2575                                ios.width(25);
2576                                left(ios);
2577                                {
2578                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2579                                    std::string ex(str, iter.base());
2580                                    assert(ex == "+0***********************");
2581                                    assert(ios.width() == 0);
2582                                }
2583                                ios.width(25);
2584                                right(ios);
2585                                {
2586                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2587                                    std::string ex(str, iter.base());
2588                                    assert(ex == "***********************+0");
2589                                    assert(ios.width() == 0);
2590                                }
2591                                ios.width(25);
2592                                internal(ios);
2593                                {
2594                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2595                                    std::string ex(str, iter.base());
2596                                    assert(ex == "+***********************0");
2597                                    assert(ios.width() == 0);
2598                                }
2599                            }
2600                            ios.imbue(lg);
2601                            {
2602                                ios.width(0);
2603                                {
2604                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2605                                    std::string ex(str, iter.base());
2606                                    assert(ex == "+0");
2607                                    assert(ios.width() == 0);
2608                                }
2609                                ios.width(25);
2610                                left(ios);
2611                                {
2612                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2613                                    std::string ex(str, iter.base());
2614                                    assert(ex == "+0***********************");
2615                                    assert(ios.width() == 0);
2616                                }
2617                                ios.width(25);
2618                                right(ios);
2619                                {
2620                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2621                                    std::string ex(str, iter.base());
2622                                    assert(ex == "***********************+0");
2623                                    assert(ios.width() == 0);
2624                                }
2625                                ios.width(25);
2626                                internal(ios);
2627                                {
2628                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2629                                    std::string ex(str, iter.base());
2630                                    assert(ex == "+***********************0");
2631                                    assert(ios.width() == 0);
2632                                }
2633                            }
2634                        }
2635                        showpoint(ios);
2636                        {
2637                            ios.imbue(lc);
2638                            {
2639                                ios.width(0);
2640                                {
2641                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2642                                    std::string ex(str, iter.base());
2643                                    assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2644                                    assert(ios.width() == 0);
2645                                }
2646                                ios.width(25);
2647                                left(ios);
2648                                {
2649                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2650                                    std::string ex(str, iter.base());
2651                                    assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2652                                    assert(ios.width() == 0);
2653                                }
2654                                ios.width(25);
2655                                right(ios);
2656                                {
2657                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2658                                    std::string ex(str, iter.base());
2659                                    assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2660                                    assert(ios.width() == 0);
2661                                }
2662                                ios.width(25);
2663                                internal(ios);
2664                                {
2665                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2666                                    std::string ex(str, iter.base());
2667                                    assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2668                                    assert(ios.width() == 0);
2669                                }
2670                            }
2671                            ios.imbue(lg);
2672                            {
2673                                ios.width(0);
2674                                {
2675                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2676                                    std::string ex(str, iter.base());
2677                                    assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2678                                    assert(ios.width() == 0);
2679                                }
2680                                ios.width(25);
2681                                left(ios);
2682                                {
2683                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2684                                    std::string ex(str, iter.base());
2685                                    assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2686                                    assert(ios.width() == 0);
2687                                }
2688                                ios.width(25);
2689                                right(ios);
2690                                {
2691                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2692                                    std::string ex(str, iter.base());
2693                                    assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2694                                    assert(ios.width() == 0);
2695                                }
2696                                ios.width(25);
2697                                internal(ios);
2698                                {
2699                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2700                                    std::string ex(str, iter.base());
2701                                    assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2702                                    assert(ios.width() == 0);
2703                                }
2704                            }
2705                        }
2706                    }
2707                }
2708                uppercase(ios);
2709                {
2710                    noshowpos(ios);
2711                    {
2712                        noshowpoint(ios);
2713                        {
2714                            ios.imbue(lc);
2715                            {
2716                                ios.width(0);
2717                                {
2718                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2719                                    std::string ex(str, iter.base());
2720                                    assert(ex == "0");
2721                                    assert(ios.width() == 0);
2722                                }
2723                                ios.width(25);
2724                                left(ios);
2725                                {
2726                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2727                                    std::string ex(str, iter.base());
2728                                    assert(ex == "0************************");
2729                                    assert(ios.width() == 0);
2730                                }
2731                                ios.width(25);
2732                                right(ios);
2733                                {
2734                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2735                                    std::string ex(str, iter.base());
2736                                    assert(ex == "************************0");
2737                                    assert(ios.width() == 0);
2738                                }
2739                                ios.width(25);
2740                                internal(ios);
2741                                {
2742                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2743                                    std::string ex(str, iter.base());
2744                                    assert(ex == "************************0");
2745                                    assert(ios.width() == 0);
2746                                }
2747                            }
2748                            ios.imbue(lg);
2749                            {
2750                                ios.width(0);
2751                                {
2752                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2753                                    std::string ex(str, iter.base());
2754                                    assert(ex == "0");
2755                                    assert(ios.width() == 0);
2756                                }
2757                                ios.width(25);
2758                                left(ios);
2759                                {
2760                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2761                                    std::string ex(str, iter.base());
2762                                    assert(ex == "0************************");
2763                                    assert(ios.width() == 0);
2764                                }
2765                                ios.width(25);
2766                                right(ios);
2767                                {
2768                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2769                                    std::string ex(str, iter.base());
2770                                    assert(ex == "************************0");
2771                                    assert(ios.width() == 0);
2772                                }
2773                                ios.width(25);
2774                                internal(ios);
2775                                {
2776                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2777                                    std::string ex(str, iter.base());
2778                                    assert(ex == "************************0");
2779                                    assert(ios.width() == 0);
2780                                }
2781                            }
2782                        }
2783                        showpoint(ios);
2784                        {
2785                            ios.imbue(lc);
2786                            {
2787                                ios.width(0);
2788                                {
2789                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2790                                    std::string ex(str, iter.base());
2791                                    assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2792                                    assert(ios.width() == 0);
2793                                }
2794                                ios.width(25);
2795                                left(ios);
2796                                {
2797                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2798                                    std::string ex(str, iter.base());
2799                                    assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2800                                    assert(ios.width() == 0);
2801                                }
2802                                ios.width(25);
2803                                right(ios);
2804                                {
2805                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2806                                    std::string ex(str, iter.base());
2807                                    assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2808                                    assert(ios.width() == 0);
2809                                }
2810                                ios.width(25);
2811                                internal(ios);
2812                                {
2813                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2814                                    std::string ex(str, iter.base());
2815                                    assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
2816                                    assert(ios.width() == 0);
2817                                }
2818                            }
2819                            ios.imbue(lg);
2820                            {
2821                                ios.width(0);
2822                                {
2823                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2824                                    std::string ex(str, iter.base());
2825                                    assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2826                                    assert(ios.width() == 0);
2827                                }
2828                                ios.width(25);
2829                                left(ios);
2830                                {
2831                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2832                                    std::string ex(str, iter.base());
2833                                    assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2834                                    assert(ios.width() == 0);
2835                                }
2836                                ios.width(25);
2837                                right(ios);
2838                                {
2839                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2840                                    std::string ex(str, iter.base());
2841                                    assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2842                                    assert(ios.width() == 0);
2843                                }
2844                                ios.width(25);
2845                                internal(ios);
2846                                {
2847                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2848                                    std::string ex(str, iter.base());
2849                                    assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
2850                                    assert(ios.width() == 0);
2851                                }
2852                            }
2853                        }
2854                    }
2855                    showpos(ios);
2856                    {
2857                        noshowpoint(ios);
2858                        {
2859                            ios.imbue(lc);
2860                            {
2861                                ios.width(0);
2862                                {
2863                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2864                                    std::string ex(str, iter.base());
2865                                    assert(ex == "+0");
2866                                    assert(ios.width() == 0);
2867                                }
2868                                ios.width(25);
2869                                left(ios);
2870                                {
2871                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2872                                    std::string ex(str, iter.base());
2873                                    assert(ex == "+0***********************");
2874                                    assert(ios.width() == 0);
2875                                }
2876                                ios.width(25);
2877                                right(ios);
2878                                {
2879                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2880                                    std::string ex(str, iter.base());
2881                                    assert(ex == "***********************+0");
2882                                    assert(ios.width() == 0);
2883                                }
2884                                ios.width(25);
2885                                internal(ios);
2886                                {
2887                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2888                                    std::string ex(str, iter.base());
2889                                    assert(ex == "+***********************0");
2890                                    assert(ios.width() == 0);
2891                                }
2892                            }
2893                            ios.imbue(lg);
2894                            {
2895                                ios.width(0);
2896                                {
2897                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2898                                    std::string ex(str, iter.base());
2899                                    assert(ex == "+0");
2900                                    assert(ios.width() == 0);
2901                                }
2902                                ios.width(25);
2903                                left(ios);
2904                                {
2905                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2906                                    std::string ex(str, iter.base());
2907                                    assert(ex == "+0***********************");
2908                                    assert(ios.width() == 0);
2909                                }
2910                                ios.width(25);
2911                                right(ios);
2912                                {
2913                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2914                                    std::string ex(str, iter.base());
2915                                    assert(ex == "***********************+0");
2916                                    assert(ios.width() == 0);
2917                                }
2918                                ios.width(25);
2919                                internal(ios);
2920                                {
2921                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2922                                    std::string ex(str, iter.base());
2923                                    assert(ex == "+***********************0");
2924                                    assert(ios.width() == 0);
2925                                }
2926                            }
2927                        }
2928                        showpoint(ios);
2929                        {
2930                            ios.imbue(lc);
2931                            {
2932                                ios.width(0);
2933                                {
2934                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2935                                    std::string ex(str, iter.base());
2936                                    assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2937                                    assert(ios.width() == 0);
2938                                }
2939                                ios.width(25);
2940                                left(ios);
2941                                {
2942                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2943                                    std::string ex(str, iter.base());
2944                                    assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2945                                    assert(ios.width() == 0);
2946                                }
2947                                ios.width(25);
2948                                right(ios);
2949                                {
2950                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2951                                    std::string ex(str, iter.base());
2952                                    assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2953                                    assert(ios.width() == 0);
2954                                }
2955                                ios.width(25);
2956                                internal(ios);
2957                                {
2958                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2959                                    std::string ex(str, iter.base());
2960                                    assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
2961                                    assert(ios.width() == 0);
2962                                }
2963                            }
2964                            ios.imbue(lg);
2965                            {
2966                                ios.width(0);
2967                                {
2968                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2969                                    std::string ex(str, iter.base());
2970                                    assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2971                                    assert(ios.width() == 0);
2972                                }
2973                                ios.width(25);
2974                                left(ios);
2975                                {
2976                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2977                                    std::string ex(str, iter.base());
2978                                    assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2979                                    assert(ios.width() == 0);
2980                                }
2981                                ios.width(25);
2982                                right(ios);
2983                                {
2984                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2985                                    std::string ex(str, iter.base());
2986                                    assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2987                                    assert(ios.width() == 0);
2988                                }
2989                                ios.width(25);
2990                                internal(ios);
2991                                {
2992                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
2993                                    std::string ex(str, iter.base());
2994                                    assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
2995                                    assert(ios.width() == 0);
2996                                }
2997                            }
2998                        }
2999                    }
3000                }
3001            }
3002        }
3003    }
3004}
3005
3006void test2()
3007{
3008    char str[200];
3009    output_iterator<char*> iter;
3010    std::locale lc = std::locale::classic();
3011    std::locale lg(lc, new my_numpunct);
3012    const my_facet f(1);
3013    {
3014        long double v = -0.;
3015        std::ios ios(0);
3016        // %g
3017        {
3018            ios.precision(0);
3019            {
3020                nouppercase(ios);
3021                {
3022                    noshowpos(ios);
3023                    {
3024                        noshowpoint(ios);
3025                        {
3026                            ios.imbue(lc);
3027                            {
3028                                ios.width(0);
3029                                {
3030                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3031                                    std::string ex(str, iter.base());
3032                                    assert(ex == "-0");
3033                                    assert(ios.width() == 0);
3034                                }
3035                                ios.width(25);
3036                                left(ios);
3037                                {
3038                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3039                                    std::string ex(str, iter.base());
3040                                    assert(ex == "-0***********************");
3041                                    assert(ios.width() == 0);
3042                                }
3043                                ios.width(25);
3044                                right(ios);
3045                                {
3046                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3047                                    std::string ex(str, iter.base());
3048                                    assert(ex == "***********************-0");
3049                                    assert(ios.width() == 0);
3050                                }
3051                                ios.width(25);
3052                                internal(ios);
3053                                {
3054                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3055                                    std::string ex(str, iter.base());
3056                                    assert(ex == "-***********************0");
3057                                    assert(ios.width() == 0);
3058                                }
3059                            }
3060                            ios.imbue(lg);
3061                            {
3062                                ios.width(0);
3063                                {
3064                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3065                                    std::string ex(str, iter.base());
3066                                    assert(ex == "-0");
3067                                    assert(ios.width() == 0);
3068                                }
3069                                ios.width(25);
3070                                left(ios);
3071                                {
3072                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3073                                    std::string ex(str, iter.base());
3074                                    assert(ex == "-0***********************");
3075                                    assert(ios.width() == 0);
3076                                }
3077                                ios.width(25);
3078                                right(ios);
3079                                {
3080                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3081                                    std::string ex(str, iter.base());
3082                                    assert(ex == "***********************-0");
3083                                    assert(ios.width() == 0);
3084                                }
3085                                ios.width(25);
3086                                internal(ios);
3087                                {
3088                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3089                                    std::string ex(str, iter.base());
3090                                    assert(ex == "-***********************0");
3091                                    assert(ios.width() == 0);
3092                                }
3093                            }
3094                        }
3095                        showpoint(ios);
3096                        {
3097                            ios.imbue(lc);
3098                            {
3099                                ios.width(0);
3100                                {
3101                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3102                                    std::string ex(str, iter.base());
3103                                    assert(ex == "-0.");
3104                                    assert(ios.width() == 0);
3105                                }
3106                                ios.width(25);
3107                                left(ios);
3108                                {
3109                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3110                                    std::string ex(str, iter.base());
3111                                    assert(ex == "-0.**********************");
3112                                    assert(ios.width() == 0);
3113                                }
3114                                ios.width(25);
3115                                right(ios);
3116                                {
3117                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3118                                    std::string ex(str, iter.base());
3119                                    assert(ex == "**********************-0.");
3120                                    assert(ios.width() == 0);
3121                                }
3122                                ios.width(25);
3123                                internal(ios);
3124                                {
3125                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3126                                    std::string ex(str, iter.base());
3127                                    assert(ex == "-**********************0.");
3128                                    assert(ios.width() == 0);
3129                                }
3130                            }
3131                            ios.imbue(lg);
3132                            {
3133                                ios.width(0);
3134                                {
3135                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3136                                    std::string ex(str, iter.base());
3137                                    assert(ex == "-0;");
3138                                    assert(ios.width() == 0);
3139                                }
3140                                ios.width(25);
3141                                left(ios);
3142                                {
3143                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3144                                    std::string ex(str, iter.base());
3145                                    assert(ex == "-0;**********************");
3146                                    assert(ios.width() == 0);
3147                                }
3148                                ios.width(25);
3149                                right(ios);
3150                                {
3151                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3152                                    std::string ex(str, iter.base());
3153                                    assert(ex == "**********************-0;");
3154                                    assert(ios.width() == 0);
3155                                }
3156                                ios.width(25);
3157                                internal(ios);
3158                                {
3159                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3160                                    std::string ex(str, iter.base());
3161                                    assert(ex == "-**********************0;");
3162                                    assert(ios.width() == 0);
3163                                }
3164                            }
3165                        }
3166                    }
3167                    showpos(ios);
3168                    {
3169                        noshowpoint(ios);
3170                        {
3171                            ios.imbue(lc);
3172                            {
3173                                ios.width(0);
3174                                {
3175                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3176                                    std::string ex(str, iter.base());
3177                                    assert(ex == "-0");
3178                                    assert(ios.width() == 0);
3179                                }
3180                                ios.width(25);
3181                                left(ios);
3182                                {
3183                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3184                                    std::string ex(str, iter.base());
3185                                    assert(ex == "-0***********************");
3186                                    assert(ios.width() == 0);
3187                                }
3188                                ios.width(25);
3189                                right(ios);
3190                                {
3191                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3192                                    std::string ex(str, iter.base());
3193                                    assert(ex == "***********************-0");
3194                                    assert(ios.width() == 0);
3195                                }
3196                                ios.width(25);
3197                                internal(ios);
3198                                {
3199                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3200                                    std::string ex(str, iter.base());
3201                                    assert(ex == "-***********************0");
3202                                    assert(ios.width() == 0);
3203                                }
3204                            }
3205                            ios.imbue(lg);
3206                            {
3207                                ios.width(0);
3208                                {
3209                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3210                                    std::string ex(str, iter.base());
3211                                    assert(ex == "-0");
3212                                    assert(ios.width() == 0);
3213                                }
3214                                ios.width(25);
3215                                left(ios);
3216                                {
3217                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3218                                    std::string ex(str, iter.base());
3219                                    assert(ex == "-0***********************");
3220                                    assert(ios.width() == 0);
3221                                }
3222                                ios.width(25);
3223                                right(ios);
3224                                {
3225                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3226                                    std::string ex(str, iter.base());
3227                                    assert(ex == "***********************-0");
3228                                    assert(ios.width() == 0);
3229                                }
3230                                ios.width(25);
3231                                internal(ios);
3232                                {
3233                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3234                                    std::string ex(str, iter.base());
3235                                    assert(ex == "-***********************0");
3236                                    assert(ios.width() == 0);
3237                                }
3238                            }
3239                        }
3240                        showpoint(ios);
3241                        {
3242                            ios.imbue(lc);
3243                            {
3244                                ios.width(0);
3245                                {
3246                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3247                                    std::string ex(str, iter.base());
3248                                    assert(ex == "-0.");
3249                                    assert(ios.width() == 0);
3250                                }
3251                                ios.width(25);
3252                                left(ios);
3253                                {
3254                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3255                                    std::string ex(str, iter.base());
3256                                    assert(ex == "-0.**********************");
3257                                    assert(ios.width() == 0);
3258                                }
3259                                ios.width(25);
3260                                right(ios);
3261                                {
3262                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3263                                    std::string ex(str, iter.base());
3264                                    assert(ex == "**********************-0.");
3265                                    assert(ios.width() == 0);
3266                                }
3267                                ios.width(25);
3268                                internal(ios);
3269                                {
3270                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3271                                    std::string ex(str, iter.base());
3272                                    assert(ex == "-**********************0.");
3273                                    assert(ios.width() == 0);
3274                                }
3275                            }
3276                            ios.imbue(lg);
3277                            {
3278                                ios.width(0);
3279                                {
3280                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3281                                    std::string ex(str, iter.base());
3282                                    assert(ex == "-0;");
3283                                    assert(ios.width() == 0);
3284                                }
3285                                ios.width(25);
3286                                left(ios);
3287                                {
3288                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3289                                    std::string ex(str, iter.base());
3290                                    assert(ex == "-0;**********************");
3291                                    assert(ios.width() == 0);
3292                                }
3293                                ios.width(25);
3294                                right(ios);
3295                                {
3296                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3297                                    std::string ex(str, iter.base());
3298                                    assert(ex == "**********************-0;");
3299                                    assert(ios.width() == 0);
3300                                }
3301                                ios.width(25);
3302                                internal(ios);
3303                                {
3304                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3305                                    std::string ex(str, iter.base());
3306                                    assert(ex == "-**********************0;");
3307                                    assert(ios.width() == 0);
3308                                }
3309                            }
3310                        }
3311                    }
3312                }
3313                uppercase(ios);
3314                {
3315                    noshowpos(ios);
3316                    {
3317                        noshowpoint(ios);
3318                        {
3319                            ios.imbue(lc);
3320                            {
3321                                ios.width(0);
3322                                {
3323                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3324                                    std::string ex(str, iter.base());
3325                                    assert(ex == "-0");
3326                                    assert(ios.width() == 0);
3327                                }
3328                                ios.width(25);
3329                                left(ios);
3330                                {
3331                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3332                                    std::string ex(str, iter.base());
3333                                    assert(ex == "-0***********************");
3334                                    assert(ios.width() == 0);
3335                                }
3336                                ios.width(25);
3337                                right(ios);
3338                                {
3339                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3340                                    std::string ex(str, iter.base());
3341                                    assert(ex == "***********************-0");
3342                                    assert(ios.width() == 0);
3343                                }
3344                                ios.width(25);
3345                                internal(ios);
3346                                {
3347                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3348                                    std::string ex(str, iter.base());
3349                                    assert(ex == "-***********************0");
3350                                    assert(ios.width() == 0);
3351                                }
3352                            }
3353                            ios.imbue(lg);
3354                            {
3355                                ios.width(0);
3356                                {
3357                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3358                                    std::string ex(str, iter.base());
3359                                    assert(ex == "-0");
3360                                    assert(ios.width() == 0);
3361                                }
3362                                ios.width(25);
3363                                left(ios);
3364                                {
3365                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3366                                    std::string ex(str, iter.base());
3367                                    assert(ex == "-0***********************");
3368                                    assert(ios.width() == 0);
3369                                }
3370                                ios.width(25);
3371                                right(ios);
3372                                {
3373                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3374                                    std::string ex(str, iter.base());
3375                                    assert(ex == "***********************-0");
3376                                    assert(ios.width() == 0);
3377                                }
3378                                ios.width(25);
3379                                internal(ios);
3380                                {
3381                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3382                                    std::string ex(str, iter.base());
3383                                    assert(ex == "-***********************0");
3384                                    assert(ios.width() == 0);
3385                                }
3386                            }
3387                        }
3388                        showpoint(ios);
3389                        {
3390                            ios.imbue(lc);
3391                            {
3392                                ios.width(0);
3393                                {
3394                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3395                                    std::string ex(str, iter.base());
3396                                    assert(ex == "-0.");
3397                                    assert(ios.width() == 0);
3398                                }
3399                                ios.width(25);
3400                                left(ios);
3401                                {
3402                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3403                                    std::string ex(str, iter.base());
3404                                    assert(ex == "-0.**********************");
3405                                    assert(ios.width() == 0);
3406                                }
3407                                ios.width(25);
3408                                right(ios);
3409                                {
3410                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3411                                    std::string ex(str, iter.base());
3412                                    assert(ex == "**********************-0.");
3413                                    assert(ios.width() == 0);
3414                                }
3415                                ios.width(25);
3416                                internal(ios);
3417                                {
3418                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3419                                    std::string ex(str, iter.base());
3420                                    assert(ex == "-**********************0.");
3421                                    assert(ios.width() == 0);
3422                                }
3423                            }
3424                            ios.imbue(lg);
3425                            {
3426                                ios.width(0);
3427                                {
3428                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3429                                    std::string ex(str, iter.base());
3430                                    assert(ex == "-0;");
3431                                    assert(ios.width() == 0);
3432                                }
3433                                ios.width(25);
3434                                left(ios);
3435                                {
3436                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3437                                    std::string ex(str, iter.base());
3438                                    assert(ex == "-0;**********************");
3439                                    assert(ios.width() == 0);
3440                                }
3441                                ios.width(25);
3442                                right(ios);
3443                                {
3444                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3445                                    std::string ex(str, iter.base());
3446                                    assert(ex == "**********************-0;");
3447                                    assert(ios.width() == 0);
3448                                }
3449                                ios.width(25);
3450                                internal(ios);
3451                                {
3452                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3453                                    std::string ex(str, iter.base());
3454                                    assert(ex == "-**********************0;");
3455                                    assert(ios.width() == 0);
3456                                }
3457                            }
3458                        }
3459                    }
3460                    showpos(ios);
3461                    {
3462                        noshowpoint(ios);
3463                        {
3464                            ios.imbue(lc);
3465                            {
3466                                ios.width(0);
3467                                {
3468                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3469                                    std::string ex(str, iter.base());
3470                                    assert(ex == "-0");
3471                                    assert(ios.width() == 0);
3472                                }
3473                                ios.width(25);
3474                                left(ios);
3475                                {
3476                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3477                                    std::string ex(str, iter.base());
3478                                    assert(ex == "-0***********************");
3479                                    assert(ios.width() == 0);
3480                                }
3481                                ios.width(25);
3482                                right(ios);
3483                                {
3484                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3485                                    std::string ex(str, iter.base());
3486                                    assert(ex == "***********************-0");
3487                                    assert(ios.width() == 0);
3488                                }
3489                                ios.width(25);
3490                                internal(ios);
3491                                {
3492                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3493                                    std::string ex(str, iter.base());
3494                                    assert(ex == "-***********************0");
3495                                    assert(ios.width() == 0);
3496                                }
3497                            }
3498                            ios.imbue(lg);
3499                            {
3500                                ios.width(0);
3501                                {
3502                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3503                                    std::string ex(str, iter.base());
3504                                    assert(ex == "-0");
3505                                    assert(ios.width() == 0);
3506                                }
3507                                ios.width(25);
3508                                left(ios);
3509                                {
3510                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3511                                    std::string ex(str, iter.base());
3512                                    assert(ex == "-0***********************");
3513                                    assert(ios.width() == 0);
3514                                }
3515                                ios.width(25);
3516                                right(ios);
3517                                {
3518                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3519                                    std::string ex(str, iter.base());
3520                                    assert(ex == "***********************-0");
3521                                    assert(ios.width() == 0);
3522                                }
3523                                ios.width(25);
3524                                internal(ios);
3525                                {
3526                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3527                                    std::string ex(str, iter.base());
3528                                    assert(ex == "-***********************0");
3529                                    assert(ios.width() == 0);
3530                                }
3531                            }
3532                        }
3533                        showpoint(ios);
3534                        {
3535                            ios.imbue(lc);
3536                            {
3537                                ios.width(0);
3538                                {
3539                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3540                                    std::string ex(str, iter.base());
3541                                    assert(ex == "-0.");
3542                                    assert(ios.width() == 0);
3543                                }
3544                                ios.width(25);
3545                                left(ios);
3546                                {
3547                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3548                                    std::string ex(str, iter.base());
3549                                    assert(ex == "-0.**********************");
3550                                    assert(ios.width() == 0);
3551                                }
3552                                ios.width(25);
3553                                right(ios);
3554                                {
3555                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3556                                    std::string ex(str, iter.base());
3557                                    assert(ex == "**********************-0.");
3558                                    assert(ios.width() == 0);
3559                                }
3560                                ios.width(25);
3561                                internal(ios);
3562                                {
3563                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3564                                    std::string ex(str, iter.base());
3565                                    assert(ex == "-**********************0.");
3566                                    assert(ios.width() == 0);
3567                                }
3568                            }
3569                            ios.imbue(lg);
3570                            {
3571                                ios.width(0);
3572                                {
3573                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3574                                    std::string ex(str, iter.base());
3575                                    assert(ex == "-0;");
3576                                    assert(ios.width() == 0);
3577                                }
3578                                ios.width(25);
3579                                left(ios);
3580                                {
3581                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3582                                    std::string ex(str, iter.base());
3583                                    assert(ex == "-0;**********************");
3584                                    assert(ios.width() == 0);
3585                                }
3586                                ios.width(25);
3587                                right(ios);
3588                                {
3589                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3590                                    std::string ex(str, iter.base());
3591                                    assert(ex == "**********************-0;");
3592                                    assert(ios.width() == 0);
3593                                }
3594                                ios.width(25);
3595                                internal(ios);
3596                                {
3597                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3598                                    std::string ex(str, iter.base());
3599                                    assert(ex == "-**********************0;");
3600                                    assert(ios.width() == 0);
3601                                }
3602                            }
3603                        }
3604                    }
3605                }
3606            }
3607            ios.precision(1);
3608            {
3609                nouppercase(ios);
3610                {
3611                    noshowpos(ios);
3612                    {
3613                        noshowpoint(ios);
3614                        {
3615                            ios.imbue(lc);
3616                            {
3617                                ios.width(0);
3618                                {
3619                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3620                                    std::string ex(str, iter.base());
3621                                    assert(ex == "-0");
3622                                    assert(ios.width() == 0);
3623                                }
3624                                ios.width(25);
3625                                left(ios);
3626                                {
3627                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3628                                    std::string ex(str, iter.base());
3629                                    assert(ex == "-0***********************");
3630                                    assert(ios.width() == 0);
3631                                }
3632                                ios.width(25);
3633                                right(ios);
3634                                {
3635                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3636                                    std::string ex(str, iter.base());
3637                                    assert(ex == "***********************-0");
3638                                    assert(ios.width() == 0);
3639                                }
3640                                ios.width(25);
3641                                internal(ios);
3642                                {
3643                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3644                                    std::string ex(str, iter.base());
3645                                    assert(ex == "-***********************0");
3646                                    assert(ios.width() == 0);
3647                                }
3648                            }
3649                            ios.imbue(lg);
3650                            {
3651                                ios.width(0);
3652                                {
3653                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3654                                    std::string ex(str, iter.base());
3655                                    assert(ex == "-0");
3656                                    assert(ios.width() == 0);
3657                                }
3658                                ios.width(25);
3659                                left(ios);
3660                                {
3661                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3662                                    std::string ex(str, iter.base());
3663                                    assert(ex == "-0***********************");
3664                                    assert(ios.width() == 0);
3665                                }
3666                                ios.width(25);
3667                                right(ios);
3668                                {
3669                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3670                                    std::string ex(str, iter.base());
3671                                    assert(ex == "***********************-0");
3672                                    assert(ios.width() == 0);
3673                                }
3674                                ios.width(25);
3675                                internal(ios);
3676                                {
3677                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3678                                    std::string ex(str, iter.base());
3679                                    assert(ex == "-***********************0");
3680                                    assert(ios.width() == 0);
3681                                }
3682                            }
3683                        }
3684                        showpoint(ios);
3685                        {
3686                            ios.imbue(lc);
3687                            {
3688                                ios.width(0);
3689                                {
3690                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3691                                    std::string ex(str, iter.base());
3692                                    assert(ex == "-0.");
3693                                    assert(ios.width() == 0);
3694                                }
3695                                ios.width(25);
3696                                left(ios);
3697                                {
3698                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3699                                    std::string ex(str, iter.base());
3700                                    assert(ex == "-0.**********************");
3701                                    assert(ios.width() == 0);
3702                                }
3703                                ios.width(25);
3704                                right(ios);
3705                                {
3706                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3707                                    std::string ex(str, iter.base());
3708                                    assert(ex == "**********************-0.");
3709                                    assert(ios.width() == 0);
3710                                }
3711                                ios.width(25);
3712                                internal(ios);
3713                                {
3714                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3715                                    std::string ex(str, iter.base());
3716                                    assert(ex == "-**********************0.");
3717                                    assert(ios.width() == 0);
3718                                }
3719                            }
3720                            ios.imbue(lg);
3721                            {
3722                                ios.width(0);
3723                                {
3724                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3725                                    std::string ex(str, iter.base());
3726                                    assert(ex == "-0;");
3727                                    assert(ios.width() == 0);
3728                                }
3729                                ios.width(25);
3730                                left(ios);
3731                                {
3732                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3733                                    std::string ex(str, iter.base());
3734                                    assert(ex == "-0;**********************");
3735                                    assert(ios.width() == 0);
3736                                }
3737                                ios.width(25);
3738                                right(ios);
3739                                {
3740                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3741                                    std::string ex(str, iter.base());
3742                                    assert(ex == "**********************-0;");
3743                                    assert(ios.width() == 0);
3744                                }
3745                                ios.width(25);
3746                                internal(ios);
3747                                {
3748                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3749                                    std::string ex(str, iter.base());
3750                                    assert(ex == "-**********************0;");
3751                                    assert(ios.width() == 0);
3752                                }
3753                            }
3754                        }
3755                    }
3756                    showpos(ios);
3757                    {
3758                        noshowpoint(ios);
3759                        {
3760                            ios.imbue(lc);
3761                            {
3762                                ios.width(0);
3763                                {
3764                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3765                                    std::string ex(str, iter.base());
3766                                    assert(ex == "-0");
3767                                    assert(ios.width() == 0);
3768                                }
3769                                ios.width(25);
3770                                left(ios);
3771                                {
3772                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3773                                    std::string ex(str, iter.base());
3774                                    assert(ex == "-0***********************");
3775                                    assert(ios.width() == 0);
3776                                }
3777                                ios.width(25);
3778                                right(ios);
3779                                {
3780                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3781                                    std::string ex(str, iter.base());
3782                                    assert(ex == "***********************-0");
3783                                    assert(ios.width() == 0);
3784                                }
3785                                ios.width(25);
3786                                internal(ios);
3787                                {
3788                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3789                                    std::string ex(str, iter.base());
3790                                    assert(ex == "-***********************0");
3791                                    assert(ios.width() == 0);
3792                                }
3793                            }
3794                            ios.imbue(lg);
3795                            {
3796                                ios.width(0);
3797                                {
3798                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3799                                    std::string ex(str, iter.base());
3800                                    assert(ex == "-0");
3801                                    assert(ios.width() == 0);
3802                                }
3803                                ios.width(25);
3804                                left(ios);
3805                                {
3806                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3807                                    std::string ex(str, iter.base());
3808                                    assert(ex == "-0***********************");
3809                                    assert(ios.width() == 0);
3810                                }
3811                                ios.width(25);
3812                                right(ios);
3813                                {
3814                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3815                                    std::string ex(str, iter.base());
3816                                    assert(ex == "***********************-0");
3817                                    assert(ios.width() == 0);
3818                                }
3819                                ios.width(25);
3820                                internal(ios);
3821                                {
3822                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3823                                    std::string ex(str, iter.base());
3824                                    assert(ex == "-***********************0");
3825                                    assert(ios.width() == 0);
3826                                }
3827                            }
3828                        }
3829                        showpoint(ios);
3830                        {
3831                            ios.imbue(lc);
3832                            {
3833                                ios.width(0);
3834                                {
3835                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3836                                    std::string ex(str, iter.base());
3837                                    assert(ex == "-0.");
3838                                    assert(ios.width() == 0);
3839                                }
3840                                ios.width(25);
3841                                left(ios);
3842                                {
3843                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3844                                    std::string ex(str, iter.base());
3845                                    assert(ex == "-0.**********************");
3846                                    assert(ios.width() == 0);
3847                                }
3848                                ios.width(25);
3849                                right(ios);
3850                                {
3851                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3852                                    std::string ex(str, iter.base());
3853                                    assert(ex == "**********************-0.");
3854                                    assert(ios.width() == 0);
3855                                }
3856                                ios.width(25);
3857                                internal(ios);
3858                                {
3859                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3860                                    std::string ex(str, iter.base());
3861                                    assert(ex == "-**********************0.");
3862                                    assert(ios.width() == 0);
3863                                }
3864                            }
3865                            ios.imbue(lg);
3866                            {
3867                                ios.width(0);
3868                                {
3869                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3870                                    std::string ex(str, iter.base());
3871                                    assert(ex == "-0;");
3872                                    assert(ios.width() == 0);
3873                                }
3874                                ios.width(25);
3875                                left(ios);
3876                                {
3877                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3878                                    std::string ex(str, iter.base());
3879                                    assert(ex == "-0;**********************");
3880                                    assert(ios.width() == 0);
3881                                }
3882                                ios.width(25);
3883                                right(ios);
3884                                {
3885                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3886                                    std::string ex(str, iter.base());
3887                                    assert(ex == "**********************-0;");
3888                                    assert(ios.width() == 0);
3889                                }
3890                                ios.width(25);
3891                                internal(ios);
3892                                {
3893                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3894                                    std::string ex(str, iter.base());
3895                                    assert(ex == "-**********************0;");
3896                                    assert(ios.width() == 0);
3897                                }
3898                            }
3899                        }
3900                    }
3901                }
3902                uppercase(ios);
3903                {
3904                    noshowpos(ios);
3905                    {
3906                        noshowpoint(ios);
3907                        {
3908                            ios.imbue(lc);
3909                            {
3910                                ios.width(0);
3911                                {
3912                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3913                                    std::string ex(str, iter.base());
3914                                    assert(ex == "-0");
3915                                    assert(ios.width() == 0);
3916                                }
3917                                ios.width(25);
3918                                left(ios);
3919                                {
3920                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3921                                    std::string ex(str, iter.base());
3922                                    assert(ex == "-0***********************");
3923                                    assert(ios.width() == 0);
3924                                }
3925                                ios.width(25);
3926                                right(ios);
3927                                {
3928                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3929                                    std::string ex(str, iter.base());
3930                                    assert(ex == "***********************-0");
3931                                    assert(ios.width() == 0);
3932                                }
3933                                ios.width(25);
3934                                internal(ios);
3935                                {
3936                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3937                                    std::string ex(str, iter.base());
3938                                    assert(ex == "-***********************0");
3939                                    assert(ios.width() == 0);
3940                                }
3941                            }
3942                            ios.imbue(lg);
3943                            {
3944                                ios.width(0);
3945                                {
3946                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3947                                    std::string ex(str, iter.base());
3948                                    assert(ex == "-0");
3949                                    assert(ios.width() == 0);
3950                                }
3951                                ios.width(25);
3952                                left(ios);
3953                                {
3954                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3955                                    std::string ex(str, iter.base());
3956                                    assert(ex == "-0***********************");
3957                                    assert(ios.width() == 0);
3958                                }
3959                                ios.width(25);
3960                                right(ios);
3961                                {
3962                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3963                                    std::string ex(str, iter.base());
3964                                    assert(ex == "***********************-0");
3965                                    assert(ios.width() == 0);
3966                                }
3967                                ios.width(25);
3968                                internal(ios);
3969                                {
3970                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3971                                    std::string ex(str, iter.base());
3972                                    assert(ex == "-***********************0");
3973                                    assert(ios.width() == 0);
3974                                }
3975                            }
3976                        }
3977                        showpoint(ios);
3978                        {
3979                            ios.imbue(lc);
3980                            {
3981                                ios.width(0);
3982                                {
3983                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3984                                    std::string ex(str, iter.base());
3985                                    assert(ex == "-0.");
3986                                    assert(ios.width() == 0);
3987                                }
3988                                ios.width(25);
3989                                left(ios);
3990                                {
3991                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
3992                                    std::string ex(str, iter.base());
3993                                    assert(ex == "-0.**********************");
3994                                    assert(ios.width() == 0);
3995                                }
3996                                ios.width(25);
3997                                right(ios);
3998                                {
3999                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4000                                    std::string ex(str, iter.base());
4001                                    assert(ex == "**********************-0.");
4002                                    assert(ios.width() == 0);
4003                                }
4004                                ios.width(25);
4005                                internal(ios);
4006                                {
4007                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4008                                    std::string ex(str, iter.base());
4009                                    assert(ex == "-**********************0.");
4010                                    assert(ios.width() == 0);
4011                                }
4012                            }
4013                            ios.imbue(lg);
4014                            {
4015                                ios.width(0);
4016                                {
4017                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4018                                    std::string ex(str, iter.base());
4019                                    assert(ex == "-0;");
4020                                    assert(ios.width() == 0);
4021                                }
4022                                ios.width(25);
4023                                left(ios);
4024                                {
4025                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4026                                    std::string ex(str, iter.base());
4027                                    assert(ex == "-0;**********************");
4028                                    assert(ios.width() == 0);
4029                                }
4030                                ios.width(25);
4031                                right(ios);
4032                                {
4033                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4034                                    std::string ex(str, iter.base());
4035                                    assert(ex == "**********************-0;");
4036                                    assert(ios.width() == 0);
4037                                }
4038                                ios.width(25);
4039                                internal(ios);
4040                                {
4041                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4042                                    std::string ex(str, iter.base());
4043                                    assert(ex == "-**********************0;");
4044                                    assert(ios.width() == 0);
4045                                }
4046                            }
4047                        }
4048                    }
4049                    showpos(ios);
4050                    {
4051                        noshowpoint(ios);
4052                        {
4053                            ios.imbue(lc);
4054                            {
4055                                ios.width(0);
4056                                {
4057                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4058                                    std::string ex(str, iter.base());
4059                                    assert(ex == "-0");
4060                                    assert(ios.width() == 0);
4061                                }
4062                                ios.width(25);
4063                                left(ios);
4064                                {
4065                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4066                                    std::string ex(str, iter.base());
4067                                    assert(ex == "-0***********************");
4068                                    assert(ios.width() == 0);
4069                                }
4070                                ios.width(25);
4071                                right(ios);
4072                                {
4073                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4074                                    std::string ex(str, iter.base());
4075                                    assert(ex == "***********************-0");
4076                                    assert(ios.width() == 0);
4077                                }
4078                                ios.width(25);
4079                                internal(ios);
4080                                {
4081                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4082                                    std::string ex(str, iter.base());
4083                                    assert(ex == "-***********************0");
4084                                    assert(ios.width() == 0);
4085                                }
4086                            }
4087                            ios.imbue(lg);
4088                            {
4089                                ios.width(0);
4090                                {
4091                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4092                                    std::string ex(str, iter.base());
4093                                    assert(ex == "-0");
4094                                    assert(ios.width() == 0);
4095                                }
4096                                ios.width(25);
4097                                left(ios);
4098                                {
4099                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4100                                    std::string ex(str, iter.base());
4101                                    assert(ex == "-0***********************");
4102                                    assert(ios.width() == 0);
4103                                }
4104                                ios.width(25);
4105                                right(ios);
4106                                {
4107                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4108                                    std::string ex(str, iter.base());
4109                                    assert(ex == "***********************-0");
4110                                    assert(ios.width() == 0);
4111                                }
4112                                ios.width(25);
4113                                internal(ios);
4114                                {
4115                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4116                                    std::string ex(str, iter.base());
4117                                    assert(ex == "-***********************0");
4118                                    assert(ios.width() == 0);
4119                                }
4120                            }
4121                        }
4122                        showpoint(ios);
4123                        {
4124                            ios.imbue(lc);
4125                            {
4126                                ios.width(0);
4127                                {
4128                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4129                                    std::string ex(str, iter.base());
4130                                    assert(ex == "-0.");
4131                                    assert(ios.width() == 0);
4132                                }
4133                                ios.width(25);
4134                                left(ios);
4135                                {
4136                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4137                                    std::string ex(str, iter.base());
4138                                    assert(ex == "-0.**********************");
4139                                    assert(ios.width() == 0);
4140                                }
4141                                ios.width(25);
4142                                right(ios);
4143                                {
4144                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4145                                    std::string ex(str, iter.base());
4146                                    assert(ex == "**********************-0.");
4147                                    assert(ios.width() == 0);
4148                                }
4149                                ios.width(25);
4150                                internal(ios);
4151                                {
4152                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4153                                    std::string ex(str, iter.base());
4154                                    assert(ex == "-**********************0.");
4155                                    assert(ios.width() == 0);
4156                                }
4157                            }
4158                            ios.imbue(lg);
4159                            {
4160                                ios.width(0);
4161                                {
4162                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4163                                    std::string ex(str, iter.base());
4164                                    assert(ex == "-0;");
4165                                    assert(ios.width() == 0);
4166                                }
4167                                ios.width(25);
4168                                left(ios);
4169                                {
4170                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4171                                    std::string ex(str, iter.base());
4172                                    assert(ex == "-0;**********************");
4173                                    assert(ios.width() == 0);
4174                                }
4175                                ios.width(25);
4176                                right(ios);
4177                                {
4178                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4179                                    std::string ex(str, iter.base());
4180                                    assert(ex == "**********************-0;");
4181                                    assert(ios.width() == 0);
4182                                }
4183                                ios.width(25);
4184                                internal(ios);
4185                                {
4186                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4187                                    std::string ex(str, iter.base());
4188                                    assert(ex == "-**********************0;");
4189                                    assert(ios.width() == 0);
4190                                }
4191                            }
4192                        }
4193                    }
4194                }
4195            }
4196            ios.precision(6);
4197            {
4198                nouppercase(ios);
4199                {
4200                    noshowpos(ios);
4201                    {
4202                        noshowpoint(ios);
4203                        {
4204                            ios.imbue(lc);
4205                            {
4206                                ios.width(0);
4207                                {
4208                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4209                                    std::string ex(str, iter.base());
4210                                    assert(ex == "-0");
4211                                    assert(ios.width() == 0);
4212                                }
4213                                ios.width(25);
4214                                left(ios);
4215                                {
4216                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4217                                    std::string ex(str, iter.base());
4218                                    assert(ex == "-0***********************");
4219                                    assert(ios.width() == 0);
4220                                }
4221                                ios.width(25);
4222                                right(ios);
4223                                {
4224                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4225                                    std::string ex(str, iter.base());
4226                                    assert(ex == "***********************-0");
4227                                    assert(ios.width() == 0);
4228                                }
4229                                ios.width(25);
4230                                internal(ios);
4231                                {
4232                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4233                                    std::string ex(str, iter.base());
4234                                    assert(ex == "-***********************0");
4235                                    assert(ios.width() == 0);
4236                                }
4237                            }
4238                            ios.imbue(lg);
4239                            {
4240                                ios.width(0);
4241                                {
4242                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4243                                    std::string ex(str, iter.base());
4244                                    assert(ex == "-0");
4245                                    assert(ios.width() == 0);
4246                                }
4247                                ios.width(25);
4248                                left(ios);
4249                                {
4250                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4251                                    std::string ex(str, iter.base());
4252                                    assert(ex == "-0***********************");
4253                                    assert(ios.width() == 0);
4254                                }
4255                                ios.width(25);
4256                                right(ios);
4257                                {
4258                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4259                                    std::string ex(str, iter.base());
4260                                    assert(ex == "***********************-0");
4261                                    assert(ios.width() == 0);
4262                                }
4263                                ios.width(25);
4264                                internal(ios);
4265                                {
4266                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4267                                    std::string ex(str, iter.base());
4268                                    assert(ex == "-***********************0");
4269                                    assert(ios.width() == 0);
4270                                }
4271                            }
4272                        }
4273                        showpoint(ios);
4274                        {
4275                            ios.imbue(lc);
4276                            {
4277                                ios.width(0);
4278                                {
4279                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4280                                    std::string ex(str, iter.base());
4281                                    assert(ex == "-0.00000");
4282                                    assert(ios.width() == 0);
4283                                }
4284                                ios.width(25);
4285                                left(ios);
4286                                {
4287                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4288                                    std::string ex(str, iter.base());
4289                                    assert(ex == "-0.00000*****************");
4290                                    assert(ios.width() == 0);
4291                                }
4292                                ios.width(25);
4293                                right(ios);
4294                                {
4295                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4296                                    std::string ex(str, iter.base());
4297                                    assert(ex == "*****************-0.00000");
4298                                    assert(ios.width() == 0);
4299                                }
4300                                ios.width(25);
4301                                internal(ios);
4302                                {
4303                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4304                                    std::string ex(str, iter.base());
4305                                    assert(ex == "-*****************0.00000");
4306                                    assert(ios.width() == 0);
4307                                }
4308                            }
4309                            ios.imbue(lg);
4310                            {
4311                                ios.width(0);
4312                                {
4313                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4314                                    std::string ex(str, iter.base());
4315                                    assert(ex == "-0;00000");
4316                                    assert(ios.width() == 0);
4317                                }
4318                                ios.width(25);
4319                                left(ios);
4320                                {
4321                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4322                                    std::string ex(str, iter.base());
4323                                    assert(ex == "-0;00000*****************");
4324                                    assert(ios.width() == 0);
4325                                }
4326                                ios.width(25);
4327                                right(ios);
4328                                {
4329                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4330                                    std::string ex(str, iter.base());
4331                                    assert(ex == "*****************-0;00000");
4332                                    assert(ios.width() == 0);
4333                                }
4334                                ios.width(25);
4335                                internal(ios);
4336                                {
4337                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4338                                    std::string ex(str, iter.base());
4339                                    assert(ex == "-*****************0;00000");
4340                                    assert(ios.width() == 0);
4341                                }
4342                            }
4343                        }
4344                    }
4345                    showpos(ios);
4346                    {
4347                        noshowpoint(ios);
4348                        {
4349                            ios.imbue(lc);
4350                            {
4351                                ios.width(0);
4352                                {
4353                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4354                                    std::string ex(str, iter.base());
4355                                    assert(ex == "-0");
4356                                    assert(ios.width() == 0);
4357                                }
4358                                ios.width(25);
4359                                left(ios);
4360                                {
4361                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4362                                    std::string ex(str, iter.base());
4363                                    assert(ex == "-0***********************");
4364                                    assert(ios.width() == 0);
4365                                }
4366                                ios.width(25);
4367                                right(ios);
4368                                {
4369                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4370                                    std::string ex(str, iter.base());
4371                                    assert(ex == "***********************-0");
4372                                    assert(ios.width() == 0);
4373                                }
4374                                ios.width(25);
4375                                internal(ios);
4376                                {
4377                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4378                                    std::string ex(str, iter.base());
4379                                    assert(ex == "-***********************0");
4380                                    assert(ios.width() == 0);
4381                                }
4382                            }
4383                            ios.imbue(lg);
4384                            {
4385                                ios.width(0);
4386                                {
4387                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4388                                    std::string ex(str, iter.base());
4389                                    assert(ex == "-0");
4390                                    assert(ios.width() == 0);
4391                                }
4392                                ios.width(25);
4393                                left(ios);
4394                                {
4395                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4396                                    std::string ex(str, iter.base());
4397                                    assert(ex == "-0***********************");
4398                                    assert(ios.width() == 0);
4399                                }
4400                                ios.width(25);
4401                                right(ios);
4402                                {
4403                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4404                                    std::string ex(str, iter.base());
4405                                    assert(ex == "***********************-0");
4406                                    assert(ios.width() == 0);
4407                                }
4408                                ios.width(25);
4409                                internal(ios);
4410                                {
4411                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4412                                    std::string ex(str, iter.base());
4413                                    assert(ex == "-***********************0");
4414                                    assert(ios.width() == 0);
4415                                }
4416                            }
4417                        }
4418                        showpoint(ios);
4419                        {
4420                            ios.imbue(lc);
4421                            {
4422                                ios.width(0);
4423                                {
4424                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4425                                    std::string ex(str, iter.base());
4426                                    assert(ex == "-0.00000");
4427                                    assert(ios.width() == 0);
4428                                }
4429                                ios.width(25);
4430                                left(ios);
4431                                {
4432                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4433                                    std::string ex(str, iter.base());
4434                                    assert(ex == "-0.00000*****************");
4435                                    assert(ios.width() == 0);
4436                                }
4437                                ios.width(25);
4438                                right(ios);
4439                                {
4440                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4441                                    std::string ex(str, iter.base());
4442                                    assert(ex == "*****************-0.00000");
4443                                    assert(ios.width() == 0);
4444                                }
4445                                ios.width(25);
4446                                internal(ios);
4447                                {
4448                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4449                                    std::string ex(str, iter.base());
4450                                    assert(ex == "-*****************0.00000");
4451                                    assert(ios.width() == 0);
4452                                }
4453                            }
4454                            ios.imbue(lg);
4455                            {
4456                                ios.width(0);
4457                                {
4458                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4459                                    std::string ex(str, iter.base());
4460                                    assert(ex == "-0;00000");
4461                                    assert(ios.width() == 0);
4462                                }
4463                                ios.width(25);
4464                                left(ios);
4465                                {
4466                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4467                                    std::string ex(str, iter.base());
4468                                    assert(ex == "-0;00000*****************");
4469                                    assert(ios.width() == 0);
4470                                }
4471                                ios.width(25);
4472                                right(ios);
4473                                {
4474                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4475                                    std::string ex(str, iter.base());
4476                                    assert(ex == "*****************-0;00000");
4477                                    assert(ios.width() == 0);
4478                                }
4479                                ios.width(25);
4480                                internal(ios);
4481                                {
4482                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4483                                    std::string ex(str, iter.base());
4484                                    assert(ex == "-*****************0;00000");
4485                                    assert(ios.width() == 0);
4486                                }
4487                            }
4488                        }
4489                    }
4490                }
4491                uppercase(ios);
4492                {
4493                    noshowpos(ios);
4494                    {
4495                        noshowpoint(ios);
4496                        {
4497                            ios.imbue(lc);
4498                            {
4499                                ios.width(0);
4500                                {
4501                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4502                                    std::string ex(str, iter.base());
4503                                    assert(ex == "-0");
4504                                    assert(ios.width() == 0);
4505                                }
4506                                ios.width(25);
4507                                left(ios);
4508                                {
4509                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4510                                    std::string ex(str, iter.base());
4511                                    assert(ex == "-0***********************");
4512                                    assert(ios.width() == 0);
4513                                }
4514                                ios.width(25);
4515                                right(ios);
4516                                {
4517                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4518                                    std::string ex(str, iter.base());
4519                                    assert(ex == "***********************-0");
4520                                    assert(ios.width() == 0);
4521                                }
4522                                ios.width(25);
4523                                internal(ios);
4524                                {
4525                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4526                                    std::string ex(str, iter.base());
4527                                    assert(ex == "-***********************0");
4528                                    assert(ios.width() == 0);
4529                                }
4530                            }
4531                            ios.imbue(lg);
4532                            {
4533                                ios.width(0);
4534                                {
4535                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4536                                    std::string ex(str, iter.base());
4537                                    assert(ex == "-0");
4538                                    assert(ios.width() == 0);
4539                                }
4540                                ios.width(25);
4541                                left(ios);
4542                                {
4543                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4544                                    std::string ex(str, iter.base());
4545                                    assert(ex == "-0***********************");
4546                                    assert(ios.width() == 0);
4547                                }
4548                                ios.width(25);
4549                                right(ios);
4550                                {
4551                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4552                                    std::string ex(str, iter.base());
4553                                    assert(ex == "***********************-0");
4554                                    assert(ios.width() == 0);
4555                                }
4556                                ios.width(25);
4557                                internal(ios);
4558                                {
4559                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4560                                    std::string ex(str, iter.base());
4561                                    assert(ex == "-***********************0");
4562                                    assert(ios.width() == 0);
4563                                }
4564                            }
4565                        }
4566                        showpoint(ios);
4567                        {
4568                            ios.imbue(lc);
4569                            {
4570                                ios.width(0);
4571                                {
4572                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4573                                    std::string ex(str, iter.base());
4574                                    assert(ex == "-0.00000");
4575                                    assert(ios.width() == 0);
4576                                }
4577                                ios.width(25);
4578                                left(ios);
4579                                {
4580                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4581                                    std::string ex(str, iter.base());
4582                                    assert(ex == "-0.00000*****************");
4583                                    assert(ios.width() == 0);
4584                                }
4585                                ios.width(25);
4586                                right(ios);
4587                                {
4588                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4589                                    std::string ex(str, iter.base());
4590                                    assert(ex == "*****************-0.00000");
4591                                    assert(ios.width() == 0);
4592                                }
4593                                ios.width(25);
4594                                internal(ios);
4595                                {
4596                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4597                                    std::string ex(str, iter.base());
4598                                    assert(ex == "-*****************0.00000");
4599                                    assert(ios.width() == 0);
4600                                }
4601                            }
4602                            ios.imbue(lg);
4603                            {
4604                                ios.width(0);
4605                                {
4606                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4607                                    std::string ex(str, iter.base());
4608                                    assert(ex == "-0;00000");
4609                                    assert(ios.width() == 0);
4610                                }
4611                                ios.width(25);
4612                                left(ios);
4613                                {
4614                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4615                                    std::string ex(str, iter.base());
4616                                    assert(ex == "-0;00000*****************");
4617                                    assert(ios.width() == 0);
4618                                }
4619                                ios.width(25);
4620                                right(ios);
4621                                {
4622                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4623                                    std::string ex(str, iter.base());
4624                                    assert(ex == "*****************-0;00000");
4625                                    assert(ios.width() == 0);
4626                                }
4627                                ios.width(25);
4628                                internal(ios);
4629                                {
4630                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4631                                    std::string ex(str, iter.base());
4632                                    assert(ex == "-*****************0;00000");
4633                                    assert(ios.width() == 0);
4634                                }
4635                            }
4636                        }
4637                    }
4638                    showpos(ios);
4639                    {
4640                        noshowpoint(ios);
4641                        {
4642                            ios.imbue(lc);
4643                            {
4644                                ios.width(0);
4645                                {
4646                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4647                                    std::string ex(str, iter.base());
4648                                    assert(ex == "-0");
4649                                    assert(ios.width() == 0);
4650                                }
4651                                ios.width(25);
4652                                left(ios);
4653                                {
4654                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4655                                    std::string ex(str, iter.base());
4656                                    assert(ex == "-0***********************");
4657                                    assert(ios.width() == 0);
4658                                }
4659                                ios.width(25);
4660                                right(ios);
4661                                {
4662                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4663                                    std::string ex(str, iter.base());
4664                                    assert(ex == "***********************-0");
4665                                    assert(ios.width() == 0);
4666                                }
4667                                ios.width(25);
4668                                internal(ios);
4669                                {
4670                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4671                                    std::string ex(str, iter.base());
4672                                    assert(ex == "-***********************0");
4673                                    assert(ios.width() == 0);
4674                                }
4675                            }
4676                            ios.imbue(lg);
4677                            {
4678                                ios.width(0);
4679                                {
4680                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4681                                    std::string ex(str, iter.base());
4682                                    assert(ex == "-0");
4683                                    assert(ios.width() == 0);
4684                                }
4685                                ios.width(25);
4686                                left(ios);
4687                                {
4688                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4689                                    std::string ex(str, iter.base());
4690                                    assert(ex == "-0***********************");
4691                                    assert(ios.width() == 0);
4692                                }
4693                                ios.width(25);
4694                                right(ios);
4695                                {
4696                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4697                                    std::string ex(str, iter.base());
4698                                    assert(ex == "***********************-0");
4699                                    assert(ios.width() == 0);
4700                                }
4701                                ios.width(25);
4702                                internal(ios);
4703                                {
4704                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4705                                    std::string ex(str, iter.base());
4706                                    assert(ex == "-***********************0");
4707                                    assert(ios.width() == 0);
4708                                }
4709                            }
4710                        }
4711                        showpoint(ios);
4712                        {
4713                            ios.imbue(lc);
4714                            {
4715                                ios.width(0);
4716                                {
4717                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4718                                    std::string ex(str, iter.base());
4719                                    assert(ex == "-0.00000");
4720                                    assert(ios.width() == 0);
4721                                }
4722                                ios.width(25);
4723                                left(ios);
4724                                {
4725                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4726                                    std::string ex(str, iter.base());
4727                                    assert(ex == "-0.00000*****************");
4728                                    assert(ios.width() == 0);
4729                                }
4730                                ios.width(25);
4731                                right(ios);
4732                                {
4733                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4734                                    std::string ex(str, iter.base());
4735                                    assert(ex == "*****************-0.00000");
4736                                    assert(ios.width() == 0);
4737                                }
4738                                ios.width(25);
4739                                internal(ios);
4740                                {
4741                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4742                                    std::string ex(str, iter.base());
4743                                    assert(ex == "-*****************0.00000");
4744                                    assert(ios.width() == 0);
4745                                }
4746                            }
4747                            ios.imbue(lg);
4748                            {
4749                                ios.width(0);
4750                                {
4751                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4752                                    std::string ex(str, iter.base());
4753                                    assert(ex == "-0;00000");
4754                                    assert(ios.width() == 0);
4755                                }
4756                                ios.width(25);
4757                                left(ios);
4758                                {
4759                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4760                                    std::string ex(str, iter.base());
4761                                    assert(ex == "-0;00000*****************");
4762                                    assert(ios.width() == 0);
4763                                }
4764                                ios.width(25);
4765                                right(ios);
4766                                {
4767                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4768                                    std::string ex(str, iter.base());
4769                                    assert(ex == "*****************-0;00000");
4770                                    assert(ios.width() == 0);
4771                                }
4772                                ios.width(25);
4773                                internal(ios);
4774                                {
4775                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4776                                    std::string ex(str, iter.base());
4777                                    assert(ex == "-*****************0;00000");
4778                                    assert(ios.width() == 0);
4779                                }
4780                            }
4781                        }
4782                    }
4783                }
4784            }
4785            ios.precision(16);
4786            {
4787                nouppercase(ios);
4788                {
4789                    noshowpos(ios);
4790                    {
4791                        noshowpoint(ios);
4792                        {
4793                            ios.imbue(lc);
4794                            {
4795                                ios.width(0);
4796                                {
4797                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4798                                    std::string ex(str, iter.base());
4799                                    assert(ex == "-0");
4800                                    assert(ios.width() == 0);
4801                                }
4802                                ios.width(25);
4803                                left(ios);
4804                                {
4805                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4806                                    std::string ex(str, iter.base());
4807                                    assert(ex == "-0***********************");
4808                                    assert(ios.width() == 0);
4809                                }
4810                                ios.width(25);
4811                                right(ios);
4812                                {
4813                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4814                                    std::string ex(str, iter.base());
4815                                    assert(ex == "***********************-0");
4816                                    assert(ios.width() == 0);
4817                                }
4818                                ios.width(25);
4819                                internal(ios);
4820                                {
4821                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4822                                    std::string ex(str, iter.base());
4823                                    assert(ex == "-***********************0");
4824                                    assert(ios.width() == 0);
4825                                }
4826                            }
4827                            ios.imbue(lg);
4828                            {
4829                                ios.width(0);
4830                                {
4831                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4832                                    std::string ex(str, iter.base());
4833                                    assert(ex == "-0");
4834                                    assert(ios.width() == 0);
4835                                }
4836                                ios.width(25);
4837                                left(ios);
4838                                {
4839                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4840                                    std::string ex(str, iter.base());
4841                                    assert(ex == "-0***********************");
4842                                    assert(ios.width() == 0);
4843                                }
4844                                ios.width(25);
4845                                right(ios);
4846                                {
4847                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4848                                    std::string ex(str, iter.base());
4849                                    assert(ex == "***********************-0");
4850                                    assert(ios.width() == 0);
4851                                }
4852                                ios.width(25);
4853                                internal(ios);
4854                                {
4855                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4856                                    std::string ex(str, iter.base());
4857                                    assert(ex == "-***********************0");
4858                                    assert(ios.width() == 0);
4859                                }
4860                            }
4861                        }
4862                        showpoint(ios);
4863                        {
4864                            ios.imbue(lc);
4865                            {
4866                                ios.width(0);
4867                                {
4868                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4869                                    std::string ex(str, iter.base());
4870                                    assert(ex == "-0.000000000000000");
4871                                    assert(ios.width() == 0);
4872                                }
4873                                ios.width(25);
4874                                left(ios);
4875                                {
4876                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4877                                    std::string ex(str, iter.base());
4878                                    assert(ex == "-0.000000000000000*******");
4879                                    assert(ios.width() == 0);
4880                                }
4881                                ios.width(25);
4882                                right(ios);
4883                                {
4884                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4885                                    std::string ex(str, iter.base());
4886                                    assert(ex == "*******-0.000000000000000");
4887                                    assert(ios.width() == 0);
4888                                }
4889                                ios.width(25);
4890                                internal(ios);
4891                                {
4892                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4893                                    std::string ex(str, iter.base());
4894                                    assert(ex == "-*******0.000000000000000");
4895                                    assert(ios.width() == 0);
4896                                }
4897                            }
4898                            ios.imbue(lg);
4899                            {
4900                                ios.width(0);
4901                                {
4902                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4903                                    std::string ex(str, iter.base());
4904                                    assert(ex == "-0;000000000000000");
4905                                    assert(ios.width() == 0);
4906                                }
4907                                ios.width(25);
4908                                left(ios);
4909                                {
4910                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4911                                    std::string ex(str, iter.base());
4912                                    assert(ex == "-0;000000000000000*******");
4913                                    assert(ios.width() == 0);
4914                                }
4915                                ios.width(25);
4916                                right(ios);
4917                                {
4918                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4919                                    std::string ex(str, iter.base());
4920                                    assert(ex == "*******-0;000000000000000");
4921                                    assert(ios.width() == 0);
4922                                }
4923                                ios.width(25);
4924                                internal(ios);
4925                                {
4926                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4927                                    std::string ex(str, iter.base());
4928                                    assert(ex == "-*******0;000000000000000");
4929                                    assert(ios.width() == 0);
4930                                }
4931                            }
4932                        }
4933                    }
4934                    showpos(ios);
4935                    {
4936                        noshowpoint(ios);
4937                        {
4938                            ios.imbue(lc);
4939                            {
4940                                ios.width(0);
4941                                {
4942                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4943                                    std::string ex(str, iter.base());
4944                                    assert(ex == "-0");
4945                                    assert(ios.width() == 0);
4946                                }
4947                                ios.width(25);
4948                                left(ios);
4949                                {
4950                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4951                                    std::string ex(str, iter.base());
4952                                    assert(ex == "-0***********************");
4953                                    assert(ios.width() == 0);
4954                                }
4955                                ios.width(25);
4956                                right(ios);
4957                                {
4958                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4959                                    std::string ex(str, iter.base());
4960                                    assert(ex == "***********************-0");
4961                                    assert(ios.width() == 0);
4962                                }
4963                                ios.width(25);
4964                                internal(ios);
4965                                {
4966                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4967                                    std::string ex(str, iter.base());
4968                                    assert(ex == "-***********************0");
4969                                    assert(ios.width() == 0);
4970                                }
4971                            }
4972                            ios.imbue(lg);
4973                            {
4974                                ios.width(0);
4975                                {
4976                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4977                                    std::string ex(str, iter.base());
4978                                    assert(ex == "-0");
4979                                    assert(ios.width() == 0);
4980                                }
4981                                ios.width(25);
4982                                left(ios);
4983                                {
4984                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4985                                    std::string ex(str, iter.base());
4986                                    assert(ex == "-0***********************");
4987                                    assert(ios.width() == 0);
4988                                }
4989                                ios.width(25);
4990                                right(ios);
4991                                {
4992                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
4993                                    std::string ex(str, iter.base());
4994                                    assert(ex == "***********************-0");
4995                                    assert(ios.width() == 0);
4996                                }
4997                                ios.width(25);
4998                                internal(ios);
4999                                {
5000                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5001                                    std::string ex(str, iter.base());
5002                                    assert(ex == "-***********************0");
5003                                    assert(ios.width() == 0);
5004                                }
5005                            }
5006                        }
5007                        showpoint(ios);
5008                        {
5009                            ios.imbue(lc);
5010                            {
5011                                ios.width(0);
5012                                {
5013                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5014                                    std::string ex(str, iter.base());
5015                                    assert(ex == "-0.000000000000000");
5016                                    assert(ios.width() == 0);
5017                                }
5018                                ios.width(25);
5019                                left(ios);
5020                                {
5021                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5022                                    std::string ex(str, iter.base());
5023                                    assert(ex == "-0.000000000000000*******");
5024                                    assert(ios.width() == 0);
5025                                }
5026                                ios.width(25);
5027                                right(ios);
5028                                {
5029                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5030                                    std::string ex(str, iter.base());
5031                                    assert(ex == "*******-0.000000000000000");
5032                                    assert(ios.width() == 0);
5033                                }
5034                                ios.width(25);
5035                                internal(ios);
5036                                {
5037                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5038                                    std::string ex(str, iter.base());
5039                                    assert(ex == "-*******0.000000000000000");
5040                                    assert(ios.width() == 0);
5041                                }
5042                            }
5043                            ios.imbue(lg);
5044                            {
5045                                ios.width(0);
5046                                {
5047                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5048                                    std::string ex(str, iter.base());
5049                                    assert(ex == "-0;000000000000000");
5050                                    assert(ios.width() == 0);
5051                                }
5052                                ios.width(25);
5053                                left(ios);
5054                                {
5055                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5056                                    std::string ex(str, iter.base());
5057                                    assert(ex == "-0;000000000000000*******");
5058                                    assert(ios.width() == 0);
5059                                }
5060                                ios.width(25);
5061                                right(ios);
5062                                {
5063                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5064                                    std::string ex(str, iter.base());
5065                                    assert(ex == "*******-0;000000000000000");
5066                                    assert(ios.width() == 0);
5067                                }
5068                                ios.width(25);
5069                                internal(ios);
5070                                {
5071                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5072                                    std::string ex(str, iter.base());
5073                                    assert(ex == "-*******0;000000000000000");
5074                                    assert(ios.width() == 0);
5075                                }
5076                            }
5077                        }
5078                    }
5079                }
5080                uppercase(ios);
5081                {
5082                    noshowpos(ios);
5083                    {
5084                        noshowpoint(ios);
5085                        {
5086                            ios.imbue(lc);
5087                            {
5088                                ios.width(0);
5089                                {
5090                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5091                                    std::string ex(str, iter.base());
5092                                    assert(ex == "-0");
5093                                    assert(ios.width() == 0);
5094                                }
5095                                ios.width(25);
5096                                left(ios);
5097                                {
5098                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5099                                    std::string ex(str, iter.base());
5100                                    assert(ex == "-0***********************");
5101                                    assert(ios.width() == 0);
5102                                }
5103                                ios.width(25);
5104                                right(ios);
5105                                {
5106                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5107                                    std::string ex(str, iter.base());
5108                                    assert(ex == "***********************-0");
5109                                    assert(ios.width() == 0);
5110                                }
5111                                ios.width(25);
5112                                internal(ios);
5113                                {
5114                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5115                                    std::string ex(str, iter.base());
5116                                    assert(ex == "-***********************0");
5117                                    assert(ios.width() == 0);
5118                                }
5119                            }
5120                            ios.imbue(lg);
5121                            {
5122                                ios.width(0);
5123                                {
5124                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5125                                    std::string ex(str, iter.base());
5126                                    assert(ex == "-0");
5127                                    assert(ios.width() == 0);
5128                                }
5129                                ios.width(25);
5130                                left(ios);
5131                                {
5132                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5133                                    std::string ex(str, iter.base());
5134                                    assert(ex == "-0***********************");
5135                                    assert(ios.width() == 0);
5136                                }
5137                                ios.width(25);
5138                                right(ios);
5139                                {
5140                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5141                                    std::string ex(str, iter.base());
5142                                    assert(ex == "***********************-0");
5143                                    assert(ios.width() == 0);
5144                                }
5145                                ios.width(25);
5146                                internal(ios);
5147                                {
5148                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5149                                    std::string ex(str, iter.base());
5150                                    assert(ex == "-***********************0");
5151                                    assert(ios.width() == 0);
5152                                }
5153                            }
5154                        }
5155                        showpoint(ios);
5156                        {
5157                            ios.imbue(lc);
5158                            {
5159                                ios.width(0);
5160                                {
5161                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5162                                    std::string ex(str, iter.base());
5163                                    assert(ex == "-0.000000000000000");
5164                                    assert(ios.width() == 0);
5165                                }
5166                                ios.width(25);
5167                                left(ios);
5168                                {
5169                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5170                                    std::string ex(str, iter.base());
5171                                    assert(ex == "-0.000000000000000*******");
5172                                    assert(ios.width() == 0);
5173                                }
5174                                ios.width(25);
5175                                right(ios);
5176                                {
5177                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5178                                    std::string ex(str, iter.base());
5179                                    assert(ex == "*******-0.000000000000000");
5180                                    assert(ios.width() == 0);
5181                                }
5182                                ios.width(25);
5183                                internal(ios);
5184                                {
5185                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5186                                    std::string ex(str, iter.base());
5187                                    assert(ex == "-*******0.000000000000000");
5188                                    assert(ios.width() == 0);
5189                                }
5190                            }
5191                            ios.imbue(lg);
5192                            {
5193                                ios.width(0);
5194                                {
5195                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5196                                    std::string ex(str, iter.base());
5197                                    assert(ex == "-0;000000000000000");
5198                                    assert(ios.width() == 0);
5199                                }
5200                                ios.width(25);
5201                                left(ios);
5202                                {
5203                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5204                                    std::string ex(str, iter.base());
5205                                    assert(ex == "-0;000000000000000*******");
5206                                    assert(ios.width() == 0);
5207                                }
5208                                ios.width(25);
5209                                right(ios);
5210                                {
5211                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5212                                    std::string ex(str, iter.base());
5213                                    assert(ex == "*******-0;000000000000000");
5214                                    assert(ios.width() == 0);
5215                                }
5216                                ios.width(25);
5217                                internal(ios);
5218                                {
5219                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5220                                    std::string ex(str, iter.base());
5221                                    assert(ex == "-*******0;000000000000000");
5222                                    assert(ios.width() == 0);
5223                                }
5224                            }
5225                        }
5226                    }
5227                    showpos(ios);
5228                    {
5229                        noshowpoint(ios);
5230                        {
5231                            ios.imbue(lc);
5232                            {
5233                                ios.width(0);
5234                                {
5235                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5236                                    std::string ex(str, iter.base());
5237                                    assert(ex == "-0");
5238                                    assert(ios.width() == 0);
5239                                }
5240                                ios.width(25);
5241                                left(ios);
5242                                {
5243                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5244                                    std::string ex(str, iter.base());
5245                                    assert(ex == "-0***********************");
5246                                    assert(ios.width() == 0);
5247                                }
5248                                ios.width(25);
5249                                right(ios);
5250                                {
5251                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5252                                    std::string ex(str, iter.base());
5253                                    assert(ex == "***********************-0");
5254                                    assert(ios.width() == 0);
5255                                }
5256                                ios.width(25);
5257                                internal(ios);
5258                                {
5259                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5260                                    std::string ex(str, iter.base());
5261                                    assert(ex == "-***********************0");
5262                                    assert(ios.width() == 0);
5263                                }
5264                            }
5265                            ios.imbue(lg);
5266                            {
5267                                ios.width(0);
5268                                {
5269                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5270                                    std::string ex(str, iter.base());
5271                                    assert(ex == "-0");
5272                                    assert(ios.width() == 0);
5273                                }
5274                                ios.width(25);
5275                                left(ios);
5276                                {
5277                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5278                                    std::string ex(str, iter.base());
5279                                    assert(ex == "-0***********************");
5280                                    assert(ios.width() == 0);
5281                                }
5282                                ios.width(25);
5283                                right(ios);
5284                                {
5285                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5286                                    std::string ex(str, iter.base());
5287                                    assert(ex == "***********************-0");
5288                                    assert(ios.width() == 0);
5289                                }
5290                                ios.width(25);
5291                                internal(ios);
5292                                {
5293                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5294                                    std::string ex(str, iter.base());
5295                                    assert(ex == "-***********************0");
5296                                    assert(ios.width() == 0);
5297                                }
5298                            }
5299                        }
5300                        showpoint(ios);
5301                        {
5302                            ios.imbue(lc);
5303                            {
5304                                ios.width(0);
5305                                {
5306                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5307                                    std::string ex(str, iter.base());
5308                                    assert(ex == "-0.000000000000000");
5309                                    assert(ios.width() == 0);
5310                                }
5311                                ios.width(25);
5312                                left(ios);
5313                                {
5314                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5315                                    std::string ex(str, iter.base());
5316                                    assert(ex == "-0.000000000000000*******");
5317                                    assert(ios.width() == 0);
5318                                }
5319                                ios.width(25);
5320                                right(ios);
5321                                {
5322                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5323                                    std::string ex(str, iter.base());
5324                                    assert(ex == "*******-0.000000000000000");
5325                                    assert(ios.width() == 0);
5326                                }
5327                                ios.width(25);
5328                                internal(ios);
5329                                {
5330                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5331                                    std::string ex(str, iter.base());
5332                                    assert(ex == "-*******0.000000000000000");
5333                                    assert(ios.width() == 0);
5334                                }
5335                            }
5336                            ios.imbue(lg);
5337                            {
5338                                ios.width(0);
5339                                {
5340                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5341                                    std::string ex(str, iter.base());
5342                                    assert(ex == "-0;000000000000000");
5343                                    assert(ios.width() == 0);
5344                                }
5345                                ios.width(25);
5346                                left(ios);
5347                                {
5348                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5349                                    std::string ex(str, iter.base());
5350                                    assert(ex == "-0;000000000000000*******");
5351                                    assert(ios.width() == 0);
5352                                }
5353                                ios.width(25);
5354                                right(ios);
5355                                {
5356                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5357                                    std::string ex(str, iter.base());
5358                                    assert(ex == "*******-0;000000000000000");
5359                                    assert(ios.width() == 0);
5360                                }
5361                                ios.width(25);
5362                                internal(ios);
5363                                {
5364                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5365                                    std::string ex(str, iter.base());
5366                                    assert(ex == "-*******0;000000000000000");
5367                                    assert(ios.width() == 0);
5368                                }
5369                            }
5370                        }
5371                    }
5372                }
5373            }
5374            ios.precision(60);
5375            {
5376                nouppercase(ios);
5377                {
5378                    noshowpos(ios);
5379                    {
5380                        noshowpoint(ios);
5381                        {
5382                            ios.imbue(lc);
5383                            {
5384                                ios.width(0);
5385                                {
5386                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5387                                    std::string ex(str, iter.base());
5388                                    assert(ex == "-0");
5389                                    assert(ios.width() == 0);
5390                                }
5391                                ios.width(25);
5392                                left(ios);
5393                                {
5394                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5395                                    std::string ex(str, iter.base());
5396                                    assert(ex == "-0***********************");
5397                                    assert(ios.width() == 0);
5398                                }
5399                                ios.width(25);
5400                                right(ios);
5401                                {
5402                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5403                                    std::string ex(str, iter.base());
5404                                    assert(ex == "***********************-0");
5405                                    assert(ios.width() == 0);
5406                                }
5407                                ios.width(25);
5408                                internal(ios);
5409                                {
5410                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5411                                    std::string ex(str, iter.base());
5412                                    assert(ex == "-***********************0");
5413                                    assert(ios.width() == 0);
5414                                }
5415                            }
5416                            ios.imbue(lg);
5417                            {
5418                                ios.width(0);
5419                                {
5420                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5421                                    std::string ex(str, iter.base());
5422                                    assert(ex == "-0");
5423                                    assert(ios.width() == 0);
5424                                }
5425                                ios.width(25);
5426                                left(ios);
5427                                {
5428                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5429                                    std::string ex(str, iter.base());
5430                                    assert(ex == "-0***********************");
5431                                    assert(ios.width() == 0);
5432                                }
5433                                ios.width(25);
5434                                right(ios);
5435                                {
5436                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5437                                    std::string ex(str, iter.base());
5438                                    assert(ex == "***********************-0");
5439                                    assert(ios.width() == 0);
5440                                }
5441                                ios.width(25);
5442                                internal(ios);
5443                                {
5444                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5445                                    std::string ex(str, iter.base());
5446                                    assert(ex == "-***********************0");
5447                                    assert(ios.width() == 0);
5448                                }
5449                            }
5450                        }
5451                        showpoint(ios);
5452                        {
5453                            ios.imbue(lc);
5454                            {
5455                                ios.width(0);
5456                                {
5457                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5458                                    std::string ex(str, iter.base());
5459                                    assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5460                                    assert(ios.width() == 0);
5461                                }
5462                                ios.width(25);
5463                                left(ios);
5464                                {
5465                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5466                                    std::string ex(str, iter.base());
5467                                    assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5468                                    assert(ios.width() == 0);
5469                                }
5470                                ios.width(25);
5471                                right(ios);
5472                                {
5473                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5474                                    std::string ex(str, iter.base());
5475                                    assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5476                                    assert(ios.width() == 0);
5477                                }
5478                                ios.width(25);
5479                                internal(ios);
5480                                {
5481                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5482                                    std::string ex(str, iter.base());
5483                                    assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5484                                    assert(ios.width() == 0);
5485                                }
5486                            }
5487                            ios.imbue(lg);
5488                            {
5489                                ios.width(0);
5490                                {
5491                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5492                                    std::string ex(str, iter.base());
5493                                    assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5494                                    assert(ios.width() == 0);
5495                                }
5496                                ios.width(25);
5497                                left(ios);
5498                                {
5499                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5500                                    std::string ex(str, iter.base());
5501                                    assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5502                                    assert(ios.width() == 0);
5503                                }
5504                                ios.width(25);
5505                                right(ios);
5506                                {
5507                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5508                                    std::string ex(str, iter.base());
5509                                    assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5510                                    assert(ios.width() == 0);
5511                                }
5512                                ios.width(25);
5513                                internal(ios);
5514                                {
5515                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5516                                    std::string ex(str, iter.base());
5517                                    assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5518                                    assert(ios.width() == 0);
5519                                }
5520                            }
5521                        }
5522                    }
5523                    showpos(ios);
5524                    {
5525                        noshowpoint(ios);
5526                        {
5527                            ios.imbue(lc);
5528                            {
5529                                ios.width(0);
5530                                {
5531                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5532                                    std::string ex(str, iter.base());
5533                                    assert(ex == "-0");
5534                                    assert(ios.width() == 0);
5535                                }
5536                                ios.width(25);
5537                                left(ios);
5538                                {
5539                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5540                                    std::string ex(str, iter.base());
5541                                    assert(ex == "-0***********************");
5542                                    assert(ios.width() == 0);
5543                                }
5544                                ios.width(25);
5545                                right(ios);
5546                                {
5547                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5548                                    std::string ex(str, iter.base());
5549                                    assert(ex == "***********************-0");
5550                                    assert(ios.width() == 0);
5551                                }
5552                                ios.width(25);
5553                                internal(ios);
5554                                {
5555                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5556                                    std::string ex(str, iter.base());
5557                                    assert(ex == "-***********************0");
5558                                    assert(ios.width() == 0);
5559                                }
5560                            }
5561                            ios.imbue(lg);
5562                            {
5563                                ios.width(0);
5564                                {
5565                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5566                                    std::string ex(str, iter.base());
5567                                    assert(ex == "-0");
5568                                    assert(ios.width() == 0);
5569                                }
5570                                ios.width(25);
5571                                left(ios);
5572                                {
5573                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5574                                    std::string ex(str, iter.base());
5575                                    assert(ex == "-0***********************");
5576                                    assert(ios.width() == 0);
5577                                }
5578                                ios.width(25);
5579                                right(ios);
5580                                {
5581                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5582                                    std::string ex(str, iter.base());
5583                                    assert(ex == "***********************-0");
5584                                    assert(ios.width() == 0);
5585                                }
5586                                ios.width(25);
5587                                internal(ios);
5588                                {
5589                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5590                                    std::string ex(str, iter.base());
5591                                    assert(ex == "-***********************0");
5592                                    assert(ios.width() == 0);
5593                                }
5594                            }
5595                        }
5596                        showpoint(ios);
5597                        {
5598                            ios.imbue(lc);
5599                            {
5600                                ios.width(0);
5601                                {
5602                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5603                                    std::string ex(str, iter.base());
5604                                    assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5605                                    assert(ios.width() == 0);
5606                                }
5607                                ios.width(25);
5608                                left(ios);
5609                                {
5610                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5611                                    std::string ex(str, iter.base());
5612                                    assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5613                                    assert(ios.width() == 0);
5614                                }
5615                                ios.width(25);
5616                                right(ios);
5617                                {
5618                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5619                                    std::string ex(str, iter.base());
5620                                    assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5621                                    assert(ios.width() == 0);
5622                                }
5623                                ios.width(25);
5624                                internal(ios);
5625                                {
5626                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5627                                    std::string ex(str, iter.base());
5628                                    assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5629                                    assert(ios.width() == 0);
5630                                }
5631                            }
5632                            ios.imbue(lg);
5633                            {
5634                                ios.width(0);
5635                                {
5636                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5637                                    std::string ex(str, iter.base());
5638                                    assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5639                                    assert(ios.width() == 0);
5640                                }
5641                                ios.width(25);
5642                                left(ios);
5643                                {
5644                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5645                                    std::string ex(str, iter.base());
5646                                    assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5647                                    assert(ios.width() == 0);
5648                                }
5649                                ios.width(25);
5650                                right(ios);
5651                                {
5652                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5653                                    std::string ex(str, iter.base());
5654                                    assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5655                                    assert(ios.width() == 0);
5656                                }
5657                                ios.width(25);
5658                                internal(ios);
5659                                {
5660                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5661                                    std::string ex(str, iter.base());
5662                                    assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5663                                    assert(ios.width() == 0);
5664                                }
5665                            }
5666                        }
5667                    }
5668                }
5669                uppercase(ios);
5670                {
5671                    noshowpos(ios);
5672                    {
5673                        noshowpoint(ios);
5674                        {
5675                            ios.imbue(lc);
5676                            {
5677                                ios.width(0);
5678                                {
5679                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5680                                    std::string ex(str, iter.base());
5681                                    assert(ex == "-0");
5682                                    assert(ios.width() == 0);
5683                                }
5684                                ios.width(25);
5685                                left(ios);
5686                                {
5687                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5688                                    std::string ex(str, iter.base());
5689                                    assert(ex == "-0***********************");
5690                                    assert(ios.width() == 0);
5691                                }
5692                                ios.width(25);
5693                                right(ios);
5694                                {
5695                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5696                                    std::string ex(str, iter.base());
5697                                    assert(ex == "***********************-0");
5698                                    assert(ios.width() == 0);
5699                                }
5700                                ios.width(25);
5701                                internal(ios);
5702                                {
5703                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5704                                    std::string ex(str, iter.base());
5705                                    assert(ex == "-***********************0");
5706                                    assert(ios.width() == 0);
5707                                }
5708                            }
5709                            ios.imbue(lg);
5710                            {
5711                                ios.width(0);
5712                                {
5713                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5714                                    std::string ex(str, iter.base());
5715                                    assert(ex == "-0");
5716                                    assert(ios.width() == 0);
5717                                }
5718                                ios.width(25);
5719                                left(ios);
5720                                {
5721                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5722                                    std::string ex(str, iter.base());
5723                                    assert(ex == "-0***********************");
5724                                    assert(ios.width() == 0);
5725                                }
5726                                ios.width(25);
5727                                right(ios);
5728                                {
5729                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5730                                    std::string ex(str, iter.base());
5731                                    assert(ex == "***********************-0");
5732                                    assert(ios.width() == 0);
5733                                }
5734                                ios.width(25);
5735                                internal(ios);
5736                                {
5737                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5738                                    std::string ex(str, iter.base());
5739                                    assert(ex == "-***********************0");
5740                                    assert(ios.width() == 0);
5741                                }
5742                            }
5743                        }
5744                        showpoint(ios);
5745                        {
5746                            ios.imbue(lc);
5747                            {
5748                                ios.width(0);
5749                                {
5750                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5751                                    std::string ex(str, iter.base());
5752                                    assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5753                                    assert(ios.width() == 0);
5754                                }
5755                                ios.width(25);
5756                                left(ios);
5757                                {
5758                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5759                                    std::string ex(str, iter.base());
5760                                    assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5761                                    assert(ios.width() == 0);
5762                                }
5763                                ios.width(25);
5764                                right(ios);
5765                                {
5766                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5767                                    std::string ex(str, iter.base());
5768                                    assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5769                                    assert(ios.width() == 0);
5770                                }
5771                                ios.width(25);
5772                                internal(ios);
5773                                {
5774                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5775                                    std::string ex(str, iter.base());
5776                                    assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5777                                    assert(ios.width() == 0);
5778                                }
5779                            }
5780                            ios.imbue(lg);
5781                            {
5782                                ios.width(0);
5783                                {
5784                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5785                                    std::string ex(str, iter.base());
5786                                    assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5787                                    assert(ios.width() == 0);
5788                                }
5789                                ios.width(25);
5790                                left(ios);
5791                                {
5792                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5793                                    std::string ex(str, iter.base());
5794                                    assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5795                                    assert(ios.width() == 0);
5796                                }
5797                                ios.width(25);
5798                                right(ios);
5799                                {
5800                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5801                                    std::string ex(str, iter.base());
5802                                    assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5803                                    assert(ios.width() == 0);
5804                                }
5805                                ios.width(25);
5806                                internal(ios);
5807                                {
5808                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5809                                    std::string ex(str, iter.base());
5810                                    assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5811                                    assert(ios.width() == 0);
5812                                }
5813                            }
5814                        }
5815                    }
5816                    showpos(ios);
5817                    {
5818                        noshowpoint(ios);
5819                        {
5820                            ios.imbue(lc);
5821                            {
5822                                ios.width(0);
5823                                {
5824                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5825                                    std::string ex(str, iter.base());
5826                                    assert(ex == "-0");
5827                                    assert(ios.width() == 0);
5828                                }
5829                                ios.width(25);
5830                                left(ios);
5831                                {
5832                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5833                                    std::string ex(str, iter.base());
5834                                    assert(ex == "-0***********************");
5835                                    assert(ios.width() == 0);
5836                                }
5837                                ios.width(25);
5838                                right(ios);
5839                                {
5840                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5841                                    std::string ex(str, iter.base());
5842                                    assert(ex == "***********************-0");
5843                                    assert(ios.width() == 0);
5844                                }
5845                                ios.width(25);
5846                                internal(ios);
5847                                {
5848                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5849                                    std::string ex(str, iter.base());
5850                                    assert(ex == "-***********************0");
5851                                    assert(ios.width() == 0);
5852                                }
5853                            }
5854                            ios.imbue(lg);
5855                            {
5856                                ios.width(0);
5857                                {
5858                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5859                                    std::string ex(str, iter.base());
5860                                    assert(ex == "-0");
5861                                    assert(ios.width() == 0);
5862                                }
5863                                ios.width(25);
5864                                left(ios);
5865                                {
5866                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5867                                    std::string ex(str, iter.base());
5868                                    assert(ex == "-0***********************");
5869                                    assert(ios.width() == 0);
5870                                }
5871                                ios.width(25);
5872                                right(ios);
5873                                {
5874                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5875                                    std::string ex(str, iter.base());
5876                                    assert(ex == "***********************-0");
5877                                    assert(ios.width() == 0);
5878                                }
5879                                ios.width(25);
5880                                internal(ios);
5881                                {
5882                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5883                                    std::string ex(str, iter.base());
5884                                    assert(ex == "-***********************0");
5885                                    assert(ios.width() == 0);
5886                                }
5887                            }
5888                        }
5889                        showpoint(ios);
5890                        {
5891                            ios.imbue(lc);
5892                            {
5893                                ios.width(0);
5894                                {
5895                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5896                                    std::string ex(str, iter.base());
5897                                    assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5898                                    assert(ios.width() == 0);
5899                                }
5900                                ios.width(25);
5901                                left(ios);
5902                                {
5903                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5904                                    std::string ex(str, iter.base());
5905                                    assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5906                                    assert(ios.width() == 0);
5907                                }
5908                                ios.width(25);
5909                                right(ios);
5910                                {
5911                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5912                                    std::string ex(str, iter.base());
5913                                    assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5914                                    assert(ios.width() == 0);
5915                                }
5916                                ios.width(25);
5917                                internal(ios);
5918                                {
5919                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5920                                    std::string ex(str, iter.base());
5921                                    assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
5922                                    assert(ios.width() == 0);
5923                                }
5924                            }
5925                            ios.imbue(lg);
5926                            {
5927                                ios.width(0);
5928                                {
5929                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5930                                    std::string ex(str, iter.base());
5931                                    assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5932                                    assert(ios.width() == 0);
5933                                }
5934                                ios.width(25);
5935                                left(ios);
5936                                {
5937                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5938                                    std::string ex(str, iter.base());
5939                                    assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5940                                    assert(ios.width() == 0);
5941                                }
5942                                ios.width(25);
5943                                right(ios);
5944                                {
5945                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5946                                    std::string ex(str, iter.base());
5947                                    assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5948                                    assert(ios.width() == 0);
5949                                }
5950                                ios.width(25);
5951                                internal(ios);
5952                                {
5953                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5954                                    std::string ex(str, iter.base());
5955                                    assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
5956                                    assert(ios.width() == 0);
5957                                }
5958                            }
5959                        }
5960                    }
5961                }
5962            }
5963        }
5964    }
5965}
5966
5967void test3()
5968{
5969    char str[200];
5970    output_iterator<char*> iter;
5971    std::locale lc = std::locale::classic();
5972    std::locale lg(lc, new my_numpunct);
5973    const my_facet f(1);
5974    {
5975        long double v = 1234567890.125;
5976        std::ios ios(0);
5977        // %g
5978        {
5979            ios.precision(0);
5980            {
5981                nouppercase(ios);
5982                {
5983                    noshowpos(ios);
5984                    {
5985                        noshowpoint(ios);
5986                        {
5987                            ios.imbue(lc);
5988                            {
5989                                ios.width(0);
5990                                {
5991                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
5992                                    std::string ex(str, iter.base());
5993                                    assert(ex == "1e+09");
5994                                    assert(ios.width() == 0);
5995                                }
5996                                ios.width(25);
5997                                left(ios);
5998                                {
5999                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6000                                    std::string ex(str, iter.base());
6001                                    assert(ex == "1e+09********************");
6002                                    assert(ios.width() == 0);
6003                                }
6004                                ios.width(25);
6005                                right(ios);
6006                                {
6007                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6008                                    std::string ex(str, iter.base());
6009                                    assert(ex == "********************1e+09");
6010                                    assert(ios.width() == 0);
6011                                }
6012                                ios.width(25);
6013                                internal(ios);
6014                                {
6015                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6016                                    std::string ex(str, iter.base());
6017                                    assert(ex == "********************1e+09");
6018                                    assert(ios.width() == 0);
6019                                }
6020                            }
6021                            ios.imbue(lg);
6022                            {
6023                                ios.width(0);
6024                                {
6025                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6026                                    std::string ex(str, iter.base());
6027                                    assert(ex == "1e+09");
6028                                    assert(ios.width() == 0);
6029                                }
6030                                ios.width(25);
6031                                left(ios);
6032                                {
6033                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6034                                    std::string ex(str, iter.base());
6035                                    assert(ex == "1e+09********************");
6036                                    assert(ios.width() == 0);
6037                                }
6038                                ios.width(25);
6039                                right(ios);
6040                                {
6041                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6042                                    std::string ex(str, iter.base());
6043                                    assert(ex == "********************1e+09");
6044                                    assert(ios.width() == 0);
6045                                }
6046                                ios.width(25);
6047                                internal(ios);
6048                                {
6049                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6050                                    std::string ex(str, iter.base());
6051                                    assert(ex == "********************1e+09");
6052                                    assert(ios.width() == 0);
6053                                }
6054                            }
6055                        }
6056                        showpoint(ios);
6057                        {
6058                            ios.imbue(lc);
6059                            {
6060                                ios.width(0);
6061                                {
6062                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6063                                    std::string ex(str, iter.base());
6064                                    assert(ex == "1.e+09");
6065                                    assert(ios.width() == 0);
6066                                }
6067                                ios.width(25);
6068                                left(ios);
6069                                {
6070                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6071                                    std::string ex(str, iter.base());
6072                                    assert(ex == "1.e+09*******************");
6073                                    assert(ios.width() == 0);
6074                                }
6075                                ios.width(25);
6076                                right(ios);
6077                                {
6078                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6079                                    std::string ex(str, iter.base());
6080                                    assert(ex == "*******************1.e+09");
6081                                    assert(ios.width() == 0);
6082                                }
6083                                ios.width(25);
6084                                internal(ios);
6085                                {
6086                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6087                                    std::string ex(str, iter.base());
6088                                    assert(ex == "*******************1.e+09");
6089                                    assert(ios.width() == 0);
6090                                }
6091                            }
6092                            ios.imbue(lg);
6093                            {
6094                                ios.width(0);
6095                                {
6096                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6097                                    std::string ex(str, iter.base());
6098                                    assert(ex == "1;e+09");
6099                                    assert(ios.width() == 0);
6100                                }
6101                                ios.width(25);
6102                                left(ios);
6103                                {
6104                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6105                                    std::string ex(str, iter.base());
6106                                    assert(ex == "1;e+09*******************");
6107                                    assert(ios.width() == 0);
6108                                }
6109                                ios.width(25);
6110                                right(ios);
6111                                {
6112                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6113                                    std::string ex(str, iter.base());
6114                                    assert(ex == "*******************1;e+09");
6115                                    assert(ios.width() == 0);
6116                                }
6117                                ios.width(25);
6118                                internal(ios);
6119                                {
6120                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6121                                    std::string ex(str, iter.base());
6122                                    assert(ex == "*******************1;e+09");
6123                                    assert(ios.width() == 0);
6124                                }
6125                            }
6126                        }
6127                    }
6128                    showpos(ios);
6129                    {
6130                        noshowpoint(ios);
6131                        {
6132                            ios.imbue(lc);
6133                            {
6134                                ios.width(0);
6135                                {
6136                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6137                                    std::string ex(str, iter.base());
6138                                    assert(ex == "+1e+09");
6139                                    assert(ios.width() == 0);
6140                                }
6141                                ios.width(25);
6142                                left(ios);
6143                                {
6144                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6145                                    std::string ex(str, iter.base());
6146                                    assert(ex == "+1e+09*******************");
6147                                    assert(ios.width() == 0);
6148                                }
6149                                ios.width(25);
6150                                right(ios);
6151                                {
6152                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6153                                    std::string ex(str, iter.base());
6154                                    assert(ex == "*******************+1e+09");
6155                                    assert(ios.width() == 0);
6156                                }
6157                                ios.width(25);
6158                                internal(ios);
6159                                {
6160                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6161                                    std::string ex(str, iter.base());
6162                                    assert(ex == "+*******************1e+09");
6163                                    assert(ios.width() == 0);
6164                                }
6165                            }
6166                            ios.imbue(lg);
6167                            {
6168                                ios.width(0);
6169                                {
6170                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6171                                    std::string ex(str, iter.base());
6172                                    assert(ex == "+1e+09");
6173                                    assert(ios.width() == 0);
6174                                }
6175                                ios.width(25);
6176                                left(ios);
6177                                {
6178                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6179                                    std::string ex(str, iter.base());
6180                                    assert(ex == "+1e+09*******************");
6181                                    assert(ios.width() == 0);
6182                                }
6183                                ios.width(25);
6184                                right(ios);
6185                                {
6186                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6187                                    std::string ex(str, iter.base());
6188                                    assert(ex == "*******************+1e+09");
6189                                    assert(ios.width() == 0);
6190                                }
6191                                ios.width(25);
6192                                internal(ios);
6193                                {
6194                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6195                                    std::string ex(str, iter.base());
6196                                    assert(ex == "+*******************1e+09");
6197                                    assert(ios.width() == 0);
6198                                }
6199                            }
6200                        }
6201                        showpoint(ios);
6202                        {
6203                            ios.imbue(lc);
6204                            {
6205                                ios.width(0);
6206                                {
6207                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6208                                    std::string ex(str, iter.base());
6209                                    assert(ex == "+1.e+09");
6210                                    assert(ios.width() == 0);
6211                                }
6212                                ios.width(25);
6213                                left(ios);
6214                                {
6215                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6216                                    std::string ex(str, iter.base());
6217                                    assert(ex == "+1.e+09******************");
6218                                    assert(ios.width() == 0);
6219                                }
6220                                ios.width(25);
6221                                right(ios);
6222                                {
6223                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6224                                    std::string ex(str, iter.base());
6225                                    assert(ex == "******************+1.e+09");
6226                                    assert(ios.width() == 0);
6227                                }
6228                                ios.width(25);
6229                                internal(ios);
6230                                {
6231                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6232                                    std::string ex(str, iter.base());
6233                                    assert(ex == "+******************1.e+09");
6234                                    assert(ios.width() == 0);
6235                                }
6236                            }
6237                            ios.imbue(lg);
6238                            {
6239                                ios.width(0);
6240                                {
6241                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6242                                    std::string ex(str, iter.base());
6243                                    assert(ex == "+1;e+09");
6244                                    assert(ios.width() == 0);
6245                                }
6246                                ios.width(25);
6247                                left(ios);
6248                                {
6249                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6250                                    std::string ex(str, iter.base());
6251                                    assert(ex == "+1;e+09******************");
6252                                    assert(ios.width() == 0);
6253                                }
6254                                ios.width(25);
6255                                right(ios);
6256                                {
6257                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6258                                    std::string ex(str, iter.base());
6259                                    assert(ex == "******************+1;e+09");
6260                                    assert(ios.width() == 0);
6261                                }
6262                                ios.width(25);
6263                                internal(ios);
6264                                {
6265                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6266                                    std::string ex(str, iter.base());
6267                                    assert(ex == "+******************1;e+09");
6268                                    assert(ios.width() == 0);
6269                                }
6270                            }
6271                        }
6272                    }
6273                }
6274                uppercase(ios);
6275                {
6276                    noshowpos(ios);
6277                    {
6278                        noshowpoint(ios);
6279                        {
6280                            ios.imbue(lc);
6281                            {
6282                                ios.width(0);
6283                                {
6284                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6285                                    std::string ex(str, iter.base());
6286                                    assert(ex == "1E+09");
6287                                    assert(ios.width() == 0);
6288                                }
6289                                ios.width(25);
6290                                left(ios);
6291                                {
6292                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6293                                    std::string ex(str, iter.base());
6294                                    assert(ex == "1E+09********************");
6295                                    assert(ios.width() == 0);
6296                                }
6297                                ios.width(25);
6298                                right(ios);
6299                                {
6300                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6301                                    std::string ex(str, iter.base());
6302                                    assert(ex == "********************1E+09");
6303                                    assert(ios.width() == 0);
6304                                }
6305                                ios.width(25);
6306                                internal(ios);
6307                                {
6308                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6309                                    std::string ex(str, iter.base());
6310                                    assert(ex == "********************1E+09");
6311                                    assert(ios.width() == 0);
6312                                }
6313                            }
6314                            ios.imbue(lg);
6315                            {
6316                                ios.width(0);
6317                                {
6318                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6319                                    std::string ex(str, iter.base());
6320                                    assert(ex == "1E+09");
6321                                    assert(ios.width() == 0);
6322                                }
6323                                ios.width(25);
6324                                left(ios);
6325                                {
6326                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6327                                    std::string ex(str, iter.base());
6328                                    assert(ex == "1E+09********************");
6329                                    assert(ios.width() == 0);
6330                                }
6331                                ios.width(25);
6332                                right(ios);
6333                                {
6334                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6335                                    std::string ex(str, iter.base());
6336                                    assert(ex == "********************1E+09");
6337                                    assert(ios.width() == 0);
6338                                }
6339                                ios.width(25);
6340                                internal(ios);
6341                                {
6342                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6343                                    std::string ex(str, iter.base());
6344                                    assert(ex == "********************1E+09");
6345                                    assert(ios.width() == 0);
6346                                }
6347                            }
6348                        }
6349                        showpoint(ios);
6350                        {
6351                            ios.imbue(lc);
6352                            {
6353                                ios.width(0);
6354                                {
6355                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6356                                    std::string ex(str, iter.base());
6357                                    assert(ex == "1.E+09");
6358                                    assert(ios.width() == 0);
6359                                }
6360                                ios.width(25);
6361                                left(ios);
6362                                {
6363                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6364                                    std::string ex(str, iter.base());
6365                                    assert(ex == "1.E+09*******************");
6366                                    assert(ios.width() == 0);
6367                                }
6368                                ios.width(25);
6369                                right(ios);
6370                                {
6371                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6372                                    std::string ex(str, iter.base());
6373                                    assert(ex == "*******************1.E+09");
6374                                    assert(ios.width() == 0);
6375                                }
6376                                ios.width(25);
6377                                internal(ios);
6378                                {
6379                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6380                                    std::string ex(str, iter.base());
6381                                    assert(ex == "*******************1.E+09");
6382                                    assert(ios.width() == 0);
6383                                }
6384                            }
6385                            ios.imbue(lg);
6386                            {
6387                                ios.width(0);
6388                                {
6389                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6390                                    std::string ex(str, iter.base());
6391                                    assert(ex == "1;E+09");
6392                                    assert(ios.width() == 0);
6393                                }
6394                                ios.width(25);
6395                                left(ios);
6396                                {
6397                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6398                                    std::string ex(str, iter.base());
6399                                    assert(ex == "1;E+09*******************");
6400                                    assert(ios.width() == 0);
6401                                }
6402                                ios.width(25);
6403                                right(ios);
6404                                {
6405                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6406                                    std::string ex(str, iter.base());
6407                                    assert(ex == "*******************1;E+09");
6408                                    assert(ios.width() == 0);
6409                                }
6410                                ios.width(25);
6411                                internal(ios);
6412                                {
6413                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6414                                    std::string ex(str, iter.base());
6415                                    assert(ex == "*******************1;E+09");
6416                                    assert(ios.width() == 0);
6417                                }
6418                            }
6419                        }
6420                    }
6421                    showpos(ios);
6422                    {
6423                        noshowpoint(ios);
6424                        {
6425                            ios.imbue(lc);
6426                            {
6427                                ios.width(0);
6428                                {
6429                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6430                                    std::string ex(str, iter.base());
6431                                    assert(ex == "+1E+09");
6432                                    assert(ios.width() == 0);
6433                                }
6434                                ios.width(25);
6435                                left(ios);
6436                                {
6437                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6438                                    std::string ex(str, iter.base());
6439                                    assert(ex == "+1E+09*******************");
6440                                    assert(ios.width() == 0);
6441                                }
6442                                ios.width(25);
6443                                right(ios);
6444                                {
6445                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6446                                    std::string ex(str, iter.base());
6447                                    assert(ex == "*******************+1E+09");
6448                                    assert(ios.width() == 0);
6449                                }
6450                                ios.width(25);
6451                                internal(ios);
6452                                {
6453                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6454                                    std::string ex(str, iter.base());
6455                                    assert(ex == "+*******************1E+09");
6456                                    assert(ios.width() == 0);
6457                                }
6458                            }
6459                            ios.imbue(lg);
6460                            {
6461                                ios.width(0);
6462                                {
6463                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6464                                    std::string ex(str, iter.base());
6465                                    assert(ex == "+1E+09");
6466                                    assert(ios.width() == 0);
6467                                }
6468                                ios.width(25);
6469                                left(ios);
6470                                {
6471                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6472                                    std::string ex(str, iter.base());
6473                                    assert(ex == "+1E+09*******************");
6474                                    assert(ios.width() == 0);
6475                                }
6476                                ios.width(25);
6477                                right(ios);
6478                                {
6479                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6480                                    std::string ex(str, iter.base());
6481                                    assert(ex == "*******************+1E+09");
6482                                    assert(ios.width() == 0);
6483                                }
6484                                ios.width(25);
6485                                internal(ios);
6486                                {
6487                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6488                                    std::string ex(str, iter.base());
6489                                    assert(ex == "+*******************1E+09");
6490                                    assert(ios.width() == 0);
6491                                }
6492                            }
6493                        }
6494                        showpoint(ios);
6495                        {
6496                            ios.imbue(lc);
6497                            {
6498                                ios.width(0);
6499                                {
6500                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6501                                    std::string ex(str, iter.base());
6502                                    assert(ex == "+1.E+09");
6503                                    assert(ios.width() == 0);
6504                                }
6505                                ios.width(25);
6506                                left(ios);
6507                                {
6508                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6509                                    std::string ex(str, iter.base());
6510                                    assert(ex == "+1.E+09******************");
6511                                    assert(ios.width() == 0);
6512                                }
6513                                ios.width(25);
6514                                right(ios);
6515                                {
6516                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6517                                    std::string ex(str, iter.base());
6518                                    assert(ex == "******************+1.E+09");
6519                                    assert(ios.width() == 0);
6520                                }
6521                                ios.width(25);
6522                                internal(ios);
6523                                {
6524                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6525                                    std::string ex(str, iter.base());
6526                                    assert(ex == "+******************1.E+09");
6527                                    assert(ios.width() == 0);
6528                                }
6529                            }
6530                            ios.imbue(lg);
6531                            {
6532                                ios.width(0);
6533                                {
6534                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6535                                    std::string ex(str, iter.base());
6536                                    assert(ex == "+1;E+09");
6537                                    assert(ios.width() == 0);
6538                                }
6539                                ios.width(25);
6540                                left(ios);
6541                                {
6542                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6543                                    std::string ex(str, iter.base());
6544                                    assert(ex == "+1;E+09******************");
6545                                    assert(ios.width() == 0);
6546                                }
6547                                ios.width(25);
6548                                right(ios);
6549                                {
6550                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6551                                    std::string ex(str, iter.base());
6552                                    assert(ex == "******************+1;E+09");
6553                                    assert(ios.width() == 0);
6554                                }
6555                                ios.width(25);
6556                                internal(ios);
6557                                {
6558                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6559                                    std::string ex(str, iter.base());
6560                                    assert(ex == "+******************1;E+09");
6561                                    assert(ios.width() == 0);
6562                                }
6563                            }
6564                        }
6565                    }
6566                }
6567            }
6568            ios.precision(1);
6569            {
6570                nouppercase(ios);
6571                {
6572                    noshowpos(ios);
6573                    {
6574                        noshowpoint(ios);
6575                        {
6576                            ios.imbue(lc);
6577                            {
6578                                ios.width(0);
6579                                {
6580                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6581                                    std::string ex(str, iter.base());
6582                                    assert(ex == "1e+09");
6583                                    assert(ios.width() == 0);
6584                                }
6585                                ios.width(25);
6586                                left(ios);
6587                                {
6588                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6589                                    std::string ex(str, iter.base());
6590                                    assert(ex == "1e+09********************");
6591                                    assert(ios.width() == 0);
6592                                }
6593                                ios.width(25);
6594                                right(ios);
6595                                {
6596                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6597                                    std::string ex(str, iter.base());
6598                                    assert(ex == "********************1e+09");
6599                                    assert(ios.width() == 0);
6600                                }
6601                                ios.width(25);
6602                                internal(ios);
6603                                {
6604                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6605                                    std::string ex(str, iter.base());
6606                                    assert(ex == "********************1e+09");
6607                                    assert(ios.width() == 0);
6608                                }
6609                            }
6610                            ios.imbue(lg);
6611                            {
6612                                ios.width(0);
6613                                {
6614                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6615                                    std::string ex(str, iter.base());
6616                                    assert(ex == "1e+09");
6617                                    assert(ios.width() == 0);
6618                                }
6619                                ios.width(25);
6620                                left(ios);
6621                                {
6622                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6623                                    std::string ex(str, iter.base());
6624                                    assert(ex == "1e+09********************");
6625                                    assert(ios.width() == 0);
6626                                }
6627                                ios.width(25);
6628                                right(ios);
6629                                {
6630                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6631                                    std::string ex(str, iter.base());
6632                                    assert(ex == "********************1e+09");
6633                                    assert(ios.width() == 0);
6634                                }
6635                                ios.width(25);
6636                                internal(ios);
6637                                {
6638                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6639                                    std::string ex(str, iter.base());
6640                                    assert(ex == "********************1e+09");
6641                                    assert(ios.width() == 0);
6642                                }
6643                            }
6644                        }
6645                        showpoint(ios);
6646                        {
6647                            ios.imbue(lc);
6648                            {
6649                                ios.width(0);
6650                                {
6651                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6652                                    std::string ex(str, iter.base());
6653                                    assert(ex == "1.e+09");
6654                                    assert(ios.width() == 0);
6655                                }
6656                                ios.width(25);
6657                                left(ios);
6658                                {
6659                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6660                                    std::string ex(str, iter.base());
6661                                    assert(ex == "1.e+09*******************");
6662                                    assert(ios.width() == 0);
6663                                }
6664                                ios.width(25);
6665                                right(ios);
6666                                {
6667                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6668                                    std::string ex(str, iter.base());
6669                                    assert(ex == "*******************1.e+09");
6670                                    assert(ios.width() == 0);
6671                                }
6672                                ios.width(25);
6673                                internal(ios);
6674                                {
6675                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6676                                    std::string ex(str, iter.base());
6677                                    assert(ex == "*******************1.e+09");
6678                                    assert(ios.width() == 0);
6679                                }
6680                            }
6681                            ios.imbue(lg);
6682                            {
6683                                ios.width(0);
6684                                {
6685                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6686                                    std::string ex(str, iter.base());
6687                                    assert(ex == "1;e+09");
6688                                    assert(ios.width() == 0);
6689                                }
6690                                ios.width(25);
6691                                left(ios);
6692                                {
6693                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6694                                    std::string ex(str, iter.base());
6695                                    assert(ex == "1;e+09*******************");
6696                                    assert(ios.width() == 0);
6697                                }
6698                                ios.width(25);
6699                                right(ios);
6700                                {
6701                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6702                                    std::string ex(str, iter.base());
6703                                    assert(ex == "*******************1;e+09");
6704                                    assert(ios.width() == 0);
6705                                }
6706                                ios.width(25);
6707                                internal(ios);
6708                                {
6709                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6710                                    std::string ex(str, iter.base());
6711                                    assert(ex == "*******************1;e+09");
6712                                    assert(ios.width() == 0);
6713                                }
6714                            }
6715                        }
6716                    }
6717                    showpos(ios);
6718                    {
6719                        noshowpoint(ios);
6720                        {
6721                            ios.imbue(lc);
6722                            {
6723                                ios.width(0);
6724                                {
6725                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6726                                    std::string ex(str, iter.base());
6727                                    assert(ex == "+1e+09");
6728                                    assert(ios.width() == 0);
6729                                }
6730                                ios.width(25);
6731                                left(ios);
6732                                {
6733                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6734                                    std::string ex(str, iter.base());
6735                                    assert(ex == "+1e+09*******************");
6736                                    assert(ios.width() == 0);
6737                                }
6738                                ios.width(25);
6739                                right(ios);
6740                                {
6741                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6742                                    std::string ex(str, iter.base());
6743                                    assert(ex == "*******************+1e+09");
6744                                    assert(ios.width() == 0);
6745                                }
6746                                ios.width(25);
6747                                internal(ios);
6748                                {
6749                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6750                                    std::string ex(str, iter.base());
6751                                    assert(ex == "+*******************1e+09");
6752                                    assert(ios.width() == 0);
6753                                }
6754                            }
6755                            ios.imbue(lg);
6756                            {
6757                                ios.width(0);
6758                                {
6759                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6760                                    std::string ex(str, iter.base());
6761                                    assert(ex == "+1e+09");
6762                                    assert(ios.width() == 0);
6763                                }
6764                                ios.width(25);
6765                                left(ios);
6766                                {
6767                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6768                                    std::string ex(str, iter.base());
6769                                    assert(ex == "+1e+09*******************");
6770                                    assert(ios.width() == 0);
6771                                }
6772                                ios.width(25);
6773                                right(ios);
6774                                {
6775                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6776                                    std::string ex(str, iter.base());
6777                                    assert(ex == "*******************+1e+09");
6778                                    assert(ios.width() == 0);
6779                                }
6780                                ios.width(25);
6781                                internal(ios);
6782                                {
6783                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6784                                    std::string ex(str, iter.base());
6785                                    assert(ex == "+*******************1e+09");
6786                                    assert(ios.width() == 0);
6787                                }
6788                            }
6789                        }
6790                        showpoint(ios);
6791                        {
6792                            ios.imbue(lc);
6793                            {
6794                                ios.width(0);
6795                                {
6796                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6797                                    std::string ex(str, iter.base());
6798                                    assert(ex == "+1.e+09");
6799                                    assert(ios.width() == 0);
6800                                }
6801                                ios.width(25);
6802                                left(ios);
6803                                {
6804                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6805                                    std::string ex(str, iter.base());
6806                                    assert(ex == "+1.e+09******************");
6807                                    assert(ios.width() == 0);
6808                                }
6809                                ios.width(25);
6810                                right(ios);
6811                                {
6812                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6813                                    std::string ex(str, iter.base());
6814                                    assert(ex == "******************+1.e+09");
6815                                    assert(ios.width() == 0);
6816                                }
6817                                ios.width(25);
6818                                internal(ios);
6819                                {
6820                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6821                                    std::string ex(str, iter.base());
6822                                    assert(ex == "+******************1.e+09");
6823                                    assert(ios.width() == 0);
6824                                }
6825                            }
6826                            ios.imbue(lg);
6827                            {
6828                                ios.width(0);
6829                                {
6830                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6831                                    std::string ex(str, iter.base());
6832                                    assert(ex == "+1;e+09");
6833                                    assert(ios.width() == 0);
6834                                }
6835                                ios.width(25);
6836                                left(ios);
6837                                {
6838                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6839                                    std::string ex(str, iter.base());
6840                                    assert(ex == "+1;e+09******************");
6841                                    assert(ios.width() == 0);
6842                                }
6843                                ios.width(25);
6844                                right(ios);
6845                                {
6846                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6847                                    std::string ex(str, iter.base());
6848                                    assert(ex == "******************+1;e+09");
6849                                    assert(ios.width() == 0);
6850                                }
6851                                ios.width(25);
6852                                internal(ios);
6853                                {
6854                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6855                                    std::string ex(str, iter.base());
6856                                    assert(ex == "+******************1;e+09");
6857                                    assert(ios.width() == 0);
6858                                }
6859                            }
6860                        }
6861                    }
6862                }
6863                uppercase(ios);
6864                {
6865                    noshowpos(ios);
6866                    {
6867                        noshowpoint(ios);
6868                        {
6869                            ios.imbue(lc);
6870                            {
6871                                ios.width(0);
6872                                {
6873                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6874                                    std::string ex(str, iter.base());
6875                                    assert(ex == "1E+09");
6876                                    assert(ios.width() == 0);
6877                                }
6878                                ios.width(25);
6879                                left(ios);
6880                                {
6881                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6882                                    std::string ex(str, iter.base());
6883                                    assert(ex == "1E+09********************");
6884                                    assert(ios.width() == 0);
6885                                }
6886                                ios.width(25);
6887                                right(ios);
6888                                {
6889                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6890                                    std::string ex(str, iter.base());
6891                                    assert(ex == "********************1E+09");
6892                                    assert(ios.width() == 0);
6893                                }
6894                                ios.width(25);
6895                                internal(ios);
6896                                {
6897                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6898                                    std::string ex(str, iter.base());
6899                                    assert(ex == "********************1E+09");
6900                                    assert(ios.width() == 0);
6901                                }
6902                            }
6903                            ios.imbue(lg);
6904                            {
6905                                ios.width(0);
6906                                {
6907                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6908                                    std::string ex(str, iter.base());
6909                                    assert(ex == "1E+09");
6910                                    assert(ios.width() == 0);
6911                                }
6912                                ios.width(25);
6913                                left(ios);
6914                                {
6915                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6916                                    std::string ex(str, iter.base());
6917                                    assert(ex == "1E+09********************");
6918                                    assert(ios.width() == 0);
6919                                }
6920                                ios.width(25);
6921                                right(ios);
6922                                {
6923                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6924                                    std::string ex(str, iter.base());
6925                                    assert(ex == "********************1E+09");
6926                                    assert(ios.width() == 0);
6927                                }
6928                                ios.width(25);
6929                                internal(ios);
6930                                {
6931                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6932                                    std::string ex(str, iter.base());
6933                                    assert(ex == "********************1E+09");
6934                                    assert(ios.width() == 0);
6935                                }
6936                            }
6937                        }
6938                        showpoint(ios);
6939                        {
6940                            ios.imbue(lc);
6941                            {
6942                                ios.width(0);
6943                                {
6944                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6945                                    std::string ex(str, iter.base());
6946                                    assert(ex == "1.E+09");
6947                                    assert(ios.width() == 0);
6948                                }
6949                                ios.width(25);
6950                                left(ios);
6951                                {
6952                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6953                                    std::string ex(str, iter.base());
6954                                    assert(ex == "1.E+09*******************");
6955                                    assert(ios.width() == 0);
6956                                }
6957                                ios.width(25);
6958                                right(ios);
6959                                {
6960                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6961                                    std::string ex(str, iter.base());
6962                                    assert(ex == "*******************1.E+09");
6963                                    assert(ios.width() == 0);
6964                                }
6965                                ios.width(25);
6966                                internal(ios);
6967                                {
6968                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6969                                    std::string ex(str, iter.base());
6970                                    assert(ex == "*******************1.E+09");
6971                                    assert(ios.width() == 0);
6972                                }
6973                            }
6974                            ios.imbue(lg);
6975                            {
6976                                ios.width(0);
6977                                {
6978                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6979                                    std::string ex(str, iter.base());
6980                                    assert(ex == "1;E+09");
6981                                    assert(ios.width() == 0);
6982                                }
6983                                ios.width(25);
6984                                left(ios);
6985                                {
6986                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6987                                    std::string ex(str, iter.base());
6988                                    assert(ex == "1;E+09*******************");
6989                                    assert(ios.width() == 0);
6990                                }
6991                                ios.width(25);
6992                                right(ios);
6993                                {
6994                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
6995                                    std::string ex(str, iter.base());
6996                                    assert(ex == "*******************1;E+09");
6997                                    assert(ios.width() == 0);
6998                                }
6999                                ios.width(25);
7000                                internal(ios);
7001                                {
7002                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7003                                    std::string ex(str, iter.base());
7004                                    assert(ex == "*******************1;E+09");
7005                                    assert(ios.width() == 0);
7006                                }
7007                            }
7008                        }
7009                    }
7010                    showpos(ios);
7011                    {
7012                        noshowpoint(ios);
7013                        {
7014                            ios.imbue(lc);
7015                            {
7016                                ios.width(0);
7017                                {
7018                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7019                                    std::string ex(str, iter.base());
7020                                    assert(ex == "+1E+09");
7021                                    assert(ios.width() == 0);
7022                                }
7023                                ios.width(25);
7024                                left(ios);
7025                                {
7026                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7027                                    std::string ex(str, iter.base());
7028                                    assert(ex == "+1E+09*******************");
7029                                    assert(ios.width() == 0);
7030                                }
7031                                ios.width(25);
7032                                right(ios);
7033                                {
7034                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7035                                    std::string ex(str, iter.base());
7036                                    assert(ex == "*******************+1E+09");
7037                                    assert(ios.width() == 0);
7038                                }
7039                                ios.width(25);
7040                                internal(ios);
7041                                {
7042                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7043                                    std::string ex(str, iter.base());
7044                                    assert(ex == "+*******************1E+09");
7045                                    assert(ios.width() == 0);
7046                                }
7047                            }
7048                            ios.imbue(lg);
7049                            {
7050                                ios.width(0);
7051                                {
7052                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7053                                    std::string ex(str, iter.base());
7054                                    assert(ex == "+1E+09");
7055                                    assert(ios.width() == 0);
7056                                }
7057                                ios.width(25);
7058                                left(ios);
7059                                {
7060                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7061                                    std::string ex(str, iter.base());
7062                                    assert(ex == "+1E+09*******************");
7063                                    assert(ios.width() == 0);
7064                                }
7065                                ios.width(25);
7066                                right(ios);
7067                                {
7068                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7069                                    std::string ex(str, iter.base());
7070                                    assert(ex == "*******************+1E+09");
7071                                    assert(ios.width() == 0);
7072                                }
7073                                ios.width(25);
7074                                internal(ios);
7075                                {
7076                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7077                                    std::string ex(str, iter.base());
7078                                    assert(ex == "+*******************1E+09");
7079                                    assert(ios.width() == 0);
7080                                }
7081                            }
7082                        }
7083                        showpoint(ios);
7084                        {
7085                            ios.imbue(lc);
7086                            {
7087                                ios.width(0);
7088                                {
7089                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7090                                    std::string ex(str, iter.base());
7091                                    assert(ex == "+1.E+09");
7092                                    assert(ios.width() == 0);
7093                                }
7094                                ios.width(25);
7095                                left(ios);
7096                                {
7097                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7098                                    std::string ex(str, iter.base());
7099                                    assert(ex == "+1.E+09******************");
7100                                    assert(ios.width() == 0);
7101                                }
7102                                ios.width(25);
7103                                right(ios);
7104                                {
7105                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7106                                    std::string ex(str, iter.base());
7107                                    assert(ex == "******************+1.E+09");
7108                                    assert(ios.width() == 0);
7109                                }
7110                                ios.width(25);
7111                                internal(ios);
7112                                {
7113                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7114                                    std::string ex(str, iter.base());
7115                                    assert(ex == "+******************1.E+09");
7116                                    assert(ios.width() == 0);
7117                                }
7118                            }
7119                            ios.imbue(lg);
7120                            {
7121                                ios.width(0);
7122                                {
7123                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7124                                    std::string ex(str, iter.base());
7125                                    assert(ex == "+1;E+09");
7126                                    assert(ios.width() == 0);
7127                                }
7128                                ios.width(25);
7129                                left(ios);
7130                                {
7131                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7132                                    std::string ex(str, iter.base());
7133                                    assert(ex == "+1;E+09******************");
7134                                    assert(ios.width() == 0);
7135                                }
7136                                ios.width(25);
7137                                right(ios);
7138                                {
7139                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7140                                    std::string ex(str, iter.base());
7141                                    assert(ex == "******************+1;E+09");
7142                                    assert(ios.width() == 0);
7143                                }
7144                                ios.width(25);
7145                                internal(ios);
7146                                {
7147                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7148                                    std::string ex(str, iter.base());
7149                                    assert(ex == "+******************1;E+09");
7150                                    assert(ios.width() == 0);
7151                                }
7152                            }
7153                        }
7154                    }
7155                }
7156            }
7157            ios.precision(6);
7158            {
7159                nouppercase(ios);
7160                {
7161                    noshowpos(ios);
7162                    {
7163                        noshowpoint(ios);
7164                        {
7165                            ios.imbue(lc);
7166                            {
7167                                ios.width(0);
7168                                {
7169                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7170                                    std::string ex(str, iter.base());
7171                                    assert(ex == "1.23457e+09");
7172                                    assert(ios.width() == 0);
7173                                }
7174                                ios.width(25);
7175                                left(ios);
7176                                {
7177                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7178                                    std::string ex(str, iter.base());
7179                                    assert(ex == "1.23457e+09**************");
7180                                    assert(ios.width() == 0);
7181                                }
7182                                ios.width(25);
7183                                right(ios);
7184                                {
7185                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7186                                    std::string ex(str, iter.base());
7187                                    assert(ex == "**************1.23457e+09");
7188                                    assert(ios.width() == 0);
7189                                }
7190                                ios.width(25);
7191                                internal(ios);
7192                                {
7193                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7194                                    std::string ex(str, iter.base());
7195                                    assert(ex == "**************1.23457e+09");
7196                                    assert(ios.width() == 0);
7197                                }
7198                            }
7199                            ios.imbue(lg);
7200                            {
7201                                ios.width(0);
7202                                {
7203                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7204                                    std::string ex(str, iter.base());
7205                                    assert(ex == "1;23457e+09");
7206                                    assert(ios.width() == 0);
7207                                }
7208                                ios.width(25);
7209                                left(ios);
7210                                {
7211                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7212                                    std::string ex(str, iter.base());
7213                                    assert(ex == "1;23457e+09**************");
7214                                    assert(ios.width() == 0);
7215                                }
7216                                ios.width(25);
7217                                right(ios);
7218                                {
7219                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7220                                    std::string ex(str, iter.base());
7221                                    assert(ex == "**************1;23457e+09");
7222                                    assert(ios.width() == 0);
7223                                }
7224                                ios.width(25);
7225                                internal(ios);
7226                                {
7227                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7228                                    std::string ex(str, iter.base());
7229                                    assert(ex == "**************1;23457e+09");
7230                                    assert(ios.width() == 0);
7231                                }
7232                            }
7233                        }
7234                        showpoint(ios);
7235                        {
7236                            ios.imbue(lc);
7237                            {
7238                                ios.width(0);
7239                                {
7240                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7241                                    std::string ex(str, iter.base());
7242                                    assert(ex == "1.23457e+09");
7243                                    assert(ios.width() == 0);
7244                                }
7245                                ios.width(25);
7246                                left(ios);
7247                                {
7248                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7249                                    std::string ex(str, iter.base());
7250                                    assert(ex == "1.23457e+09**************");
7251                                    assert(ios.width() == 0);
7252                                }
7253                                ios.width(25);
7254                                right(ios);
7255                                {
7256                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7257                                    std::string ex(str, iter.base());
7258                                    assert(ex == "**************1.23457e+09");
7259                                    assert(ios.width() == 0);
7260                                }
7261                                ios.width(25);
7262                                internal(ios);
7263                                {
7264                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7265                                    std::string ex(str, iter.base());
7266                                    assert(ex == "**************1.23457e+09");
7267                                    assert(ios.width() == 0);
7268                                }
7269                            }
7270                            ios.imbue(lg);
7271                            {
7272                                ios.width(0);
7273                                {
7274                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7275                                    std::string ex(str, iter.base());
7276                                    assert(ex == "1;23457e+09");
7277                                    assert(ios.width() == 0);
7278                                }
7279                                ios.width(25);
7280                                left(ios);
7281                                {
7282                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7283                                    std::string ex(str, iter.base());
7284                                    assert(ex == "1;23457e+09**************");
7285                                    assert(ios.width() == 0);
7286                                }
7287                                ios.width(25);
7288                                right(ios);
7289                                {
7290                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7291                                    std::string ex(str, iter.base());
7292                                    assert(ex == "**************1;23457e+09");
7293                                    assert(ios.width() == 0);
7294                                }
7295                                ios.width(25);
7296                                internal(ios);
7297                                {
7298                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7299                                    std::string ex(str, iter.base());
7300                                    assert(ex == "**************1;23457e+09");
7301                                    assert(ios.width() == 0);
7302                                }
7303                            }
7304                        }
7305                    }
7306                    showpos(ios);
7307                    {
7308                        noshowpoint(ios);
7309                        {
7310                            ios.imbue(lc);
7311                            {
7312                                ios.width(0);
7313                                {
7314                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7315                                    std::string ex(str, iter.base());
7316                                    assert(ex == "+1.23457e+09");
7317                                    assert(ios.width() == 0);
7318                                }
7319                                ios.width(25);
7320                                left(ios);
7321                                {
7322                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7323                                    std::string ex(str, iter.base());
7324                                    assert(ex == "+1.23457e+09*************");
7325                                    assert(ios.width() == 0);
7326                                }
7327                                ios.width(25);
7328                                right(ios);
7329                                {
7330                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7331                                    std::string ex(str, iter.base());
7332                                    assert(ex == "*************+1.23457e+09");
7333                                    assert(ios.width() == 0);
7334                                }
7335                                ios.width(25);
7336                                internal(ios);
7337                                {
7338                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7339                                    std::string ex(str, iter.base());
7340                                    assert(ex == "+*************1.23457e+09");
7341                                    assert(ios.width() == 0);
7342                                }
7343                            }
7344                            ios.imbue(lg);
7345                            {
7346                                ios.width(0);
7347                                {
7348                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7349                                    std::string ex(str, iter.base());
7350                                    assert(ex == "+1;23457e+09");
7351                                    assert(ios.width() == 0);
7352                                }
7353                                ios.width(25);
7354                                left(ios);
7355                                {
7356                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7357                                    std::string ex(str, iter.base());
7358                                    assert(ex == "+1;23457e+09*************");
7359                                    assert(ios.width() == 0);
7360                                }
7361                                ios.width(25);
7362                                right(ios);
7363                                {
7364                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7365                                    std::string ex(str, iter.base());
7366                                    assert(ex == "*************+1;23457e+09");
7367                                    assert(ios.width() == 0);
7368                                }
7369                                ios.width(25);
7370                                internal(ios);
7371                                {
7372                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7373                                    std::string ex(str, iter.base());
7374                                    assert(ex == "+*************1;23457e+09");
7375                                    assert(ios.width() == 0);
7376                                }
7377                            }
7378                        }
7379                        showpoint(ios);
7380                        {
7381                            ios.imbue(lc);
7382                            {
7383                                ios.width(0);
7384                                {
7385                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7386                                    std::string ex(str, iter.base());
7387                                    assert(ex == "+1.23457e+09");
7388                                    assert(ios.width() == 0);
7389                                }
7390                                ios.width(25);
7391                                left(ios);
7392                                {
7393                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7394                                    std::string ex(str, iter.base());
7395                                    assert(ex == "+1.23457e+09*************");
7396                                    assert(ios.width() == 0);
7397                                }
7398                                ios.width(25);
7399                                right(ios);
7400                                {
7401                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7402                                    std::string ex(str, iter.base());
7403                                    assert(ex == "*************+1.23457e+09");
7404                                    assert(ios.width() == 0);
7405                                }
7406                                ios.width(25);
7407                                internal(ios);
7408                                {
7409                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7410                                    std::string ex(str, iter.base());
7411                                    assert(ex == "+*************1.23457e+09");
7412                                    assert(ios.width() == 0);
7413                                }
7414                            }
7415                            ios.imbue(lg);
7416                            {
7417                                ios.width(0);
7418                                {
7419                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7420                                    std::string ex(str, iter.base());
7421                                    assert(ex == "+1;23457e+09");
7422                                    assert(ios.width() == 0);
7423                                }
7424                                ios.width(25);
7425                                left(ios);
7426                                {
7427                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7428                                    std::string ex(str, iter.base());
7429                                    assert(ex == "+1;23457e+09*************");
7430                                    assert(ios.width() == 0);
7431                                }
7432                                ios.width(25);
7433                                right(ios);
7434                                {
7435                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7436                                    std::string ex(str, iter.base());
7437                                    assert(ex == "*************+1;23457e+09");
7438                                    assert(ios.width() == 0);
7439                                }
7440                                ios.width(25);
7441                                internal(ios);
7442                                {
7443                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7444                                    std::string ex(str, iter.base());
7445                                    assert(ex == "+*************1;23457e+09");
7446                                    assert(ios.width() == 0);
7447                                }
7448                            }
7449                        }
7450                    }
7451                }
7452                uppercase(ios);
7453                {
7454                    noshowpos(ios);
7455                    {
7456                        noshowpoint(ios);
7457                        {
7458                            ios.imbue(lc);
7459                            {
7460                                ios.width(0);
7461                                {
7462                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7463                                    std::string ex(str, iter.base());
7464                                    assert(ex == "1.23457E+09");
7465                                    assert(ios.width() == 0);
7466                                }
7467                                ios.width(25);
7468                                left(ios);
7469                                {
7470                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7471                                    std::string ex(str, iter.base());
7472                                    assert(ex == "1.23457E+09**************");
7473                                    assert(ios.width() == 0);
7474                                }
7475                                ios.width(25);
7476                                right(ios);
7477                                {
7478                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7479                                    std::string ex(str, iter.base());
7480                                    assert(ex == "**************1.23457E+09");
7481                                    assert(ios.width() == 0);
7482                                }
7483                                ios.width(25);
7484                                internal(ios);
7485                                {
7486                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7487                                    std::string ex(str, iter.base());
7488                                    assert(ex == "**************1.23457E+09");
7489                                    assert(ios.width() == 0);
7490                                }
7491                            }
7492                            ios.imbue(lg);
7493                            {
7494                                ios.width(0);
7495                                {
7496                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7497                                    std::string ex(str, iter.base());
7498                                    assert(ex == "1;23457E+09");
7499                                    assert(ios.width() == 0);
7500                                }
7501                                ios.width(25);
7502                                left(ios);
7503                                {
7504                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7505                                    std::string ex(str, iter.base());
7506                                    assert(ex == "1;23457E+09**************");
7507                                    assert(ios.width() == 0);
7508                                }
7509                                ios.width(25);
7510                                right(ios);
7511                                {
7512                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7513                                    std::string ex(str, iter.base());
7514                                    assert(ex == "**************1;23457E+09");
7515                                    assert(ios.width() == 0);
7516                                }
7517                                ios.width(25);
7518                                internal(ios);
7519                                {
7520                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7521                                    std::string ex(str, iter.base());
7522                                    assert(ex == "**************1;23457E+09");
7523                                    assert(ios.width() == 0);
7524                                }
7525                            }
7526                        }
7527                        showpoint(ios);
7528                        {
7529                            ios.imbue(lc);
7530                            {
7531                                ios.width(0);
7532                                {
7533                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7534                                    std::string ex(str, iter.base());
7535                                    assert(ex == "1.23457E+09");
7536                                    assert(ios.width() == 0);
7537                                }
7538                                ios.width(25);
7539                                left(ios);
7540                                {
7541                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7542                                    std::string ex(str, iter.base());
7543                                    assert(ex == "1.23457E+09**************");
7544                                    assert(ios.width() == 0);
7545                                }
7546                                ios.width(25);
7547                                right(ios);
7548                                {
7549                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7550                                    std::string ex(str, iter.base());
7551                                    assert(ex == "**************1.23457E+09");
7552                                    assert(ios.width() == 0);
7553                                }
7554                                ios.width(25);
7555                                internal(ios);
7556                                {
7557                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7558                                    std::string ex(str, iter.base());
7559                                    assert(ex == "**************1.23457E+09");
7560                                    assert(ios.width() == 0);
7561                                }
7562                            }
7563                            ios.imbue(lg);
7564                            {
7565                                ios.width(0);
7566                                {
7567                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7568                                    std::string ex(str, iter.base());
7569                                    assert(ex == "1;23457E+09");
7570                                    assert(ios.width() == 0);
7571                                }
7572                                ios.width(25);
7573                                left(ios);
7574                                {
7575                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7576                                    std::string ex(str, iter.base());
7577                                    assert(ex == "1;23457E+09**************");
7578                                    assert(ios.width() == 0);
7579                                }
7580                                ios.width(25);
7581                                right(ios);
7582                                {
7583                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7584                                    std::string ex(str, iter.base());
7585                                    assert(ex == "**************1;23457E+09");
7586                                    assert(ios.width() == 0);
7587                                }
7588                                ios.width(25);
7589                                internal(ios);
7590                                {
7591                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7592                                    std::string ex(str, iter.base());
7593                                    assert(ex == "**************1;23457E+09");
7594                                    assert(ios.width() == 0);
7595                                }
7596                            }
7597                        }
7598                    }
7599                    showpos(ios);
7600                    {
7601                        noshowpoint(ios);
7602                        {
7603                            ios.imbue(lc);
7604                            {
7605                                ios.width(0);
7606                                {
7607                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7608                                    std::string ex(str, iter.base());
7609                                    assert(ex == "+1.23457E+09");
7610                                    assert(ios.width() == 0);
7611                                }
7612                                ios.width(25);
7613                                left(ios);
7614                                {
7615                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7616                                    std::string ex(str, iter.base());
7617                                    assert(ex == "+1.23457E+09*************");
7618                                    assert(ios.width() == 0);
7619                                }
7620                                ios.width(25);
7621                                right(ios);
7622                                {
7623                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7624                                    std::string ex(str, iter.base());
7625                                    assert(ex == "*************+1.23457E+09");
7626                                    assert(ios.width() == 0);
7627                                }
7628                                ios.width(25);
7629                                internal(ios);
7630                                {
7631                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7632                                    std::string ex(str, iter.base());
7633                                    assert(ex == "+*************1.23457E+09");
7634                                    assert(ios.width() == 0);
7635                                }
7636                            }
7637                            ios.imbue(lg);
7638                            {
7639                                ios.width(0);
7640                                {
7641                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7642                                    std::string ex(str, iter.base());
7643                                    assert(ex == "+1;23457E+09");
7644                                    assert(ios.width() == 0);
7645                                }
7646                                ios.width(25);
7647                                left(ios);
7648                                {
7649                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7650                                    std::string ex(str, iter.base());
7651                                    assert(ex == "+1;23457E+09*************");
7652                                    assert(ios.width() == 0);
7653                                }
7654                                ios.width(25);
7655                                right(ios);
7656                                {
7657                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7658                                    std::string ex(str, iter.base());
7659                                    assert(ex == "*************+1;23457E+09");
7660                                    assert(ios.width() == 0);
7661                                }
7662                                ios.width(25);
7663                                internal(ios);
7664                                {
7665                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7666                                    std::string ex(str, iter.base());
7667                                    assert(ex == "+*************1;23457E+09");
7668                                    assert(ios.width() == 0);
7669                                }
7670                            }
7671                        }
7672                        showpoint(ios);
7673                        {
7674                            ios.imbue(lc);
7675                            {
7676                                ios.width(0);
7677                                {
7678                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7679                                    std::string ex(str, iter.base());
7680                                    assert(ex == "+1.23457E+09");
7681                                    assert(ios.width() == 0);
7682                                }
7683                                ios.width(25);
7684                                left(ios);
7685                                {
7686                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7687                                    std::string ex(str, iter.base());
7688                                    assert(ex == "+1.23457E+09*************");
7689                                    assert(ios.width() == 0);
7690                                }
7691                                ios.width(25);
7692                                right(ios);
7693                                {
7694                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7695                                    std::string ex(str, iter.base());
7696                                    assert(ex == "*************+1.23457E+09");
7697                                    assert(ios.width() == 0);
7698                                }
7699                                ios.width(25);
7700                                internal(ios);
7701                                {
7702                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7703                                    std::string ex(str, iter.base());
7704                                    assert(ex == "+*************1.23457E+09");
7705                                    assert(ios.width() == 0);
7706                                }
7707                            }
7708                            ios.imbue(lg);
7709                            {
7710                                ios.width(0);
7711                                {
7712                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7713                                    std::string ex(str, iter.base());
7714                                    assert(ex == "+1;23457E+09");
7715                                    assert(ios.width() == 0);
7716                                }
7717                                ios.width(25);
7718                                left(ios);
7719                                {
7720                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7721                                    std::string ex(str, iter.base());
7722                                    assert(ex == "+1;23457E+09*************");
7723                                    assert(ios.width() == 0);
7724                                }
7725                                ios.width(25);
7726                                right(ios);
7727                                {
7728                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7729                                    std::string ex(str, iter.base());
7730                                    assert(ex == "*************+1;23457E+09");
7731                                    assert(ios.width() == 0);
7732                                }
7733                                ios.width(25);
7734                                internal(ios);
7735                                {
7736                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7737                                    std::string ex(str, iter.base());
7738                                    assert(ex == "+*************1;23457E+09");
7739                                    assert(ios.width() == 0);
7740                                }
7741                            }
7742                        }
7743                    }
7744                }
7745            }
7746            ios.precision(16);
7747            {
7748                nouppercase(ios);
7749                {
7750                    noshowpos(ios);
7751                    {
7752                        noshowpoint(ios);
7753                        {
7754                            ios.imbue(lc);
7755                            {
7756                                ios.width(0);
7757                                {
7758                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7759                                    std::string ex(str, iter.base());
7760                                    assert(ex == "1234567890.125");
7761                                    assert(ios.width() == 0);
7762                                }
7763                                ios.width(25);
7764                                left(ios);
7765                                {
7766                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7767                                    std::string ex(str, iter.base());
7768                                    assert(ex == "1234567890.125***********");
7769                                    assert(ios.width() == 0);
7770                                }
7771                                ios.width(25);
7772                                right(ios);
7773                                {
7774                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7775                                    std::string ex(str, iter.base());
7776                                    assert(ex == "***********1234567890.125");
7777                                    assert(ios.width() == 0);
7778                                }
7779                                ios.width(25);
7780                                internal(ios);
7781                                {
7782                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7783                                    std::string ex(str, iter.base());
7784                                    assert(ex == "***********1234567890.125");
7785                                    assert(ios.width() == 0);
7786                                }
7787                            }
7788                            ios.imbue(lg);
7789                            {
7790                                ios.width(0);
7791                                {
7792                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7793                                    std::string ex(str, iter.base());
7794                                    assert(ex == "1_234_567_89_0;125");
7795                                    assert(ios.width() == 0);
7796                                }
7797                                ios.width(25);
7798                                left(ios);
7799                                {
7800                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7801                                    std::string ex(str, iter.base());
7802                                    assert(ex == "1_234_567_89_0;125*******");
7803                                    assert(ios.width() == 0);
7804                                }
7805                                ios.width(25);
7806                                right(ios);
7807                                {
7808                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7809                                    std::string ex(str, iter.base());
7810                                    assert(ex == "*******1_234_567_89_0;125");
7811                                    assert(ios.width() == 0);
7812                                }
7813                                ios.width(25);
7814                                internal(ios);
7815                                {
7816                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7817                                    std::string ex(str, iter.base());
7818                                    assert(ex == "*******1_234_567_89_0;125");
7819                                    assert(ios.width() == 0);
7820                                }
7821                            }
7822                        }
7823                        showpoint(ios);
7824                        {
7825                            ios.imbue(lc);
7826                            {
7827                                ios.width(0);
7828                                {
7829                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7830                                    std::string ex(str, iter.base());
7831                                    assert(ex == "1234567890.125000");
7832                                    assert(ios.width() == 0);
7833                                }
7834                                ios.width(25);
7835                                left(ios);
7836                                {
7837                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7838                                    std::string ex(str, iter.base());
7839                                    assert(ex == "1234567890.125000********");
7840                                    assert(ios.width() == 0);
7841                                }
7842                                ios.width(25);
7843                                right(ios);
7844                                {
7845                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7846                                    std::string ex(str, iter.base());
7847                                    assert(ex == "********1234567890.125000");
7848                                    assert(ios.width() == 0);
7849                                }
7850                                ios.width(25);
7851                                internal(ios);
7852                                {
7853                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7854                                    std::string ex(str, iter.base());
7855                                    assert(ex == "********1234567890.125000");
7856                                    assert(ios.width() == 0);
7857                                }
7858                            }
7859                            ios.imbue(lg);
7860                            {
7861                                ios.width(0);
7862                                {
7863                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7864                                    std::string ex(str, iter.base());
7865                                    assert(ex == "1_234_567_89_0;125000");
7866                                    assert(ios.width() == 0);
7867                                }
7868                                ios.width(25);
7869                                left(ios);
7870                                {
7871                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7872                                    std::string ex(str, iter.base());
7873                                    assert(ex == "1_234_567_89_0;125000****");
7874                                    assert(ios.width() == 0);
7875                                }
7876                                ios.width(25);
7877                                right(ios);
7878                                {
7879                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7880                                    std::string ex(str, iter.base());
7881                                    assert(ex == "****1_234_567_89_0;125000");
7882                                    assert(ios.width() == 0);
7883                                }
7884                                ios.width(25);
7885                                internal(ios);
7886                                {
7887                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7888                                    std::string ex(str, iter.base());
7889                                    assert(ex == "****1_234_567_89_0;125000");
7890                                    assert(ios.width() == 0);
7891                                }
7892                            }
7893                        }
7894                    }
7895                    showpos(ios);
7896                    {
7897                        noshowpoint(ios);
7898                        {
7899                            ios.imbue(lc);
7900                            {
7901                                ios.width(0);
7902                                {
7903                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7904                                    std::string ex(str, iter.base());
7905                                    assert(ex == "+1234567890.125");
7906                                    assert(ios.width() == 0);
7907                                }
7908                                ios.width(25);
7909                                left(ios);
7910                                {
7911                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7912                                    std::string ex(str, iter.base());
7913                                    assert(ex == "+1234567890.125**********");
7914                                    assert(ios.width() == 0);
7915                                }
7916                                ios.width(25);
7917                                right(ios);
7918                                {
7919                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7920                                    std::string ex(str, iter.base());
7921                                    assert(ex == "**********+1234567890.125");
7922                                    assert(ios.width() == 0);
7923                                }
7924                                ios.width(25);
7925                                internal(ios);
7926                                {
7927                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7928                                    std::string ex(str, iter.base());
7929                                    assert(ex == "+**********1234567890.125");
7930                                    assert(ios.width() == 0);
7931                                }
7932                            }
7933                            ios.imbue(lg);
7934                            {
7935                                ios.width(0);
7936                                {
7937                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7938                                    std::string ex(str, iter.base());
7939                                    assert(ex == "+1_234_567_89_0;125");
7940                                    assert(ios.width() == 0);
7941                                }
7942                                ios.width(25);
7943                                left(ios);
7944                                {
7945                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7946                                    std::string ex(str, iter.base());
7947                                    assert(ex == "+1_234_567_89_0;125******");
7948                                    assert(ios.width() == 0);
7949                                }
7950                                ios.width(25);
7951                                right(ios);
7952                                {
7953                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7954                                    std::string ex(str, iter.base());
7955                                    assert(ex == "******+1_234_567_89_0;125");
7956                                    assert(ios.width() == 0);
7957                                }
7958                                ios.width(25);
7959                                internal(ios);
7960                                {
7961                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7962                                    std::string ex(str, iter.base());
7963                                    assert(ex == "+******1_234_567_89_0;125");
7964                                    assert(ios.width() == 0);
7965                                }
7966                            }
7967                        }
7968                        showpoint(ios);
7969                        {
7970                            ios.imbue(lc);
7971                            {
7972                                ios.width(0);
7973                                {
7974                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7975                                    std::string ex(str, iter.base());
7976                                    assert(ex == "+1234567890.125000");
7977                                    assert(ios.width() == 0);
7978                                }
7979                                ios.width(25);
7980                                left(ios);
7981                                {
7982                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7983                                    std::string ex(str, iter.base());
7984                                    assert(ex == "+1234567890.125000*******");
7985                                    assert(ios.width() == 0);
7986                                }
7987                                ios.width(25);
7988                                right(ios);
7989                                {
7990                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7991                                    std::string ex(str, iter.base());
7992                                    assert(ex == "*******+1234567890.125000");
7993                                    assert(ios.width() == 0);
7994                                }
7995                                ios.width(25);
7996                                internal(ios);
7997                                {
7998                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
7999                                    std::string ex(str, iter.base());
8000                                    assert(ex == "+*******1234567890.125000");
8001                                    assert(ios.width() == 0);
8002                                }
8003                            }
8004                            ios.imbue(lg);
8005                            {
8006                                ios.width(0);
8007                                {
8008                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8009                                    std::string ex(str, iter.base());
8010                                    assert(ex == "+1_234_567_89_0;125000");
8011                                    assert(ios.width() == 0);
8012                                }
8013                                ios.width(25);
8014                                left(ios);
8015                                {
8016                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8017                                    std::string ex(str, iter.base());
8018                                    assert(ex == "+1_234_567_89_0;125000***");
8019                                    assert(ios.width() == 0);
8020                                }
8021                                ios.width(25);
8022                                right(ios);
8023                                {
8024                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8025                                    std::string ex(str, iter.base());
8026                                    assert(ex == "***+1_234_567_89_0;125000");
8027                                    assert(ios.width() == 0);
8028                                }
8029                                ios.width(25);
8030                                internal(ios);
8031                                {
8032                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8033                                    std::string ex(str, iter.base());
8034                                    assert(ex == "+***1_234_567_89_0;125000");
8035                                    assert(ios.width() == 0);
8036                                }
8037                            }
8038                        }
8039                    }
8040                }
8041                uppercase(ios);
8042                {
8043                    noshowpos(ios);
8044                    {
8045                        noshowpoint(ios);
8046                        {
8047                            ios.imbue(lc);
8048                            {
8049                                ios.width(0);
8050                                {
8051                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8052                                    std::string ex(str, iter.base());
8053                                    assert(ex == "1234567890.125");
8054                                    assert(ios.width() == 0);
8055                                }
8056                                ios.width(25);
8057                                left(ios);
8058                                {
8059                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8060                                    std::string ex(str, iter.base());
8061                                    assert(ex == "1234567890.125***********");
8062                                    assert(ios.width() == 0);
8063                                }
8064                                ios.width(25);
8065                                right(ios);
8066                                {
8067                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8068                                    std::string ex(str, iter.base());
8069                                    assert(ex == "***********1234567890.125");
8070                                    assert(ios.width() == 0);
8071                                }
8072                                ios.width(25);
8073                                internal(ios);
8074                                {
8075                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8076                                    std::string ex(str, iter.base());
8077                                    assert(ex == "***********1234567890.125");
8078                                    assert(ios.width() == 0);
8079                                }
8080                            }
8081                            ios.imbue(lg);
8082                            {
8083                                ios.width(0);
8084                                {
8085                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8086                                    std::string ex(str, iter.base());
8087                                    assert(ex == "1_234_567_89_0;125");
8088                                    assert(ios.width() == 0);
8089                                }
8090                                ios.width(25);
8091                                left(ios);
8092                                {
8093                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8094                                    std::string ex(str, iter.base());
8095                                    assert(ex == "1_234_567_89_0;125*******");
8096                                    assert(ios.width() == 0);
8097                                }
8098                                ios.width(25);
8099                                right(ios);
8100                                {
8101                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8102                                    std::string ex(str, iter.base());
8103                                    assert(ex == "*******1_234_567_89_0;125");
8104                                    assert(ios.width() == 0);
8105                                }
8106                                ios.width(25);
8107                                internal(ios);
8108                                {
8109                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8110                                    std::string ex(str, iter.base());
8111                                    assert(ex == "*******1_234_567_89_0;125");
8112                                    assert(ios.width() == 0);
8113                                }
8114                            }
8115                        }
8116                        showpoint(ios);
8117                        {
8118                            ios.imbue(lc);
8119                            {
8120                                ios.width(0);
8121                                {
8122                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8123                                    std::string ex(str, iter.base());
8124                                    assert(ex == "1234567890.125000");
8125                                    assert(ios.width() == 0);
8126                                }
8127                                ios.width(25);
8128                                left(ios);
8129                                {
8130                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8131                                    std::string ex(str, iter.base());
8132                                    assert(ex == "1234567890.125000********");
8133                                    assert(ios.width() == 0);
8134                                }
8135                                ios.width(25);
8136                                right(ios);
8137                                {
8138                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8139                                    std::string ex(str, iter.base());
8140                                    assert(ex == "********1234567890.125000");
8141                                    assert(ios.width() == 0);
8142                                }
8143                                ios.width(25);
8144                                internal(ios);
8145                                {
8146                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8147                                    std::string ex(str, iter.base());
8148                                    assert(ex == "********1234567890.125000");
8149                                    assert(ios.width() == 0);
8150                                }
8151                            }
8152                            ios.imbue(lg);
8153                            {
8154                                ios.width(0);
8155                                {
8156                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8157                                    std::string ex(str, iter.base());
8158                                    assert(ex == "1_234_567_89_0;125000");
8159                                    assert(ios.width() == 0);
8160                                }
8161                                ios.width(25);
8162                                left(ios);
8163                                {
8164                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8165                                    std::string ex(str, iter.base());
8166                                    assert(ex == "1_234_567_89_0;125000****");
8167                                    assert(ios.width() == 0);
8168                                }
8169                                ios.width(25);
8170                                right(ios);
8171                                {
8172                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8173                                    std::string ex(str, iter.base());
8174                                    assert(ex == "****1_234_567_89_0;125000");
8175                                    assert(ios.width() == 0);
8176                                }
8177                                ios.width(25);
8178                                internal(ios);
8179                                {
8180                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8181                                    std::string ex(str, iter.base());
8182                                    assert(ex == "****1_234_567_89_0;125000");
8183                                    assert(ios.width() == 0);
8184                                }
8185                            }
8186                        }
8187                    }
8188                    showpos(ios);
8189                    {
8190                        noshowpoint(ios);
8191                        {
8192                            ios.imbue(lc);
8193                            {
8194                                ios.width(0);
8195                                {
8196                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8197                                    std::string ex(str, iter.base());
8198                                    assert(ex == "+1234567890.125");
8199                                    assert(ios.width() == 0);
8200                                }
8201                                ios.width(25);
8202                                left(ios);
8203                                {
8204                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8205                                    std::string ex(str, iter.base());
8206                                    assert(ex == "+1234567890.125**********");
8207                                    assert(ios.width() == 0);
8208                                }
8209                                ios.width(25);
8210                                right(ios);
8211                                {
8212                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8213                                    std::string ex(str, iter.base());
8214                                    assert(ex == "**********+1234567890.125");
8215                                    assert(ios.width() == 0);
8216                                }
8217                                ios.width(25);
8218                                internal(ios);
8219                                {
8220                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8221                                    std::string ex(str, iter.base());
8222                                    assert(ex == "+**********1234567890.125");
8223                                    assert(ios.width() == 0);
8224                                }
8225                            }
8226                            ios.imbue(lg);
8227                            {
8228                                ios.width(0);
8229                                {
8230                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8231                                    std::string ex(str, iter.base());
8232                                    assert(ex == "+1_234_567_89_0;125");
8233                                    assert(ios.width() == 0);
8234                                }
8235                                ios.width(25);
8236                                left(ios);
8237                                {
8238                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8239                                    std::string ex(str, iter.base());
8240                                    assert(ex == "+1_234_567_89_0;125******");
8241                                    assert(ios.width() == 0);
8242                                }
8243                                ios.width(25);
8244                                right(ios);
8245                                {
8246                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8247                                    std::string ex(str, iter.base());
8248                                    assert(ex == "******+1_234_567_89_0;125");
8249                                    assert(ios.width() == 0);
8250                                }
8251                                ios.width(25);
8252                                internal(ios);
8253                                {
8254                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8255                                    std::string ex(str, iter.base());
8256                                    assert(ex == "+******1_234_567_89_0;125");
8257                                    assert(ios.width() == 0);
8258                                }
8259                            }
8260                        }
8261                        showpoint(ios);
8262                        {
8263                            ios.imbue(lc);
8264                            {
8265                                ios.width(0);
8266                                {
8267                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8268                                    std::string ex(str, iter.base());
8269                                    assert(ex == "+1234567890.125000");
8270                                    assert(ios.width() == 0);
8271                                }
8272                                ios.width(25);
8273                                left(ios);
8274                                {
8275                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8276                                    std::string ex(str, iter.base());
8277                                    assert(ex == "+1234567890.125000*******");
8278                                    assert(ios.width() == 0);
8279                                }
8280                                ios.width(25);
8281                                right(ios);
8282                                {
8283                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8284                                    std::string ex(str, iter.base());
8285                                    assert(ex == "*******+1234567890.125000");
8286                                    assert(ios.width() == 0);
8287                                }
8288                                ios.width(25);
8289                                internal(ios);
8290                                {
8291                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8292                                    std::string ex(str, iter.base());
8293                                    assert(ex == "+*******1234567890.125000");
8294                                    assert(ios.width() == 0);
8295                                }
8296                            }
8297                            ios.imbue(lg);
8298                            {
8299                                ios.width(0);
8300                                {
8301                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8302                                    std::string ex(str, iter.base());
8303                                    assert(ex == "+1_234_567_89_0;125000");
8304                                    assert(ios.width() == 0);
8305                                }
8306                                ios.width(25);
8307                                left(ios);
8308                                {
8309                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8310                                    std::string ex(str, iter.base());
8311                                    assert(ex == "+1_234_567_89_0;125000***");
8312                                    assert(ios.width() == 0);
8313                                }
8314                                ios.width(25);
8315                                right(ios);
8316                                {
8317                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8318                                    std::string ex(str, iter.base());
8319                                    assert(ex == "***+1_234_567_89_0;125000");
8320                                    assert(ios.width() == 0);
8321                                }
8322                                ios.width(25);
8323                                internal(ios);
8324                                {
8325                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8326                                    std::string ex(str, iter.base());
8327                                    assert(ex == "+***1_234_567_89_0;125000");
8328                                    assert(ios.width() == 0);
8329                                }
8330                            }
8331                        }
8332                    }
8333                }
8334            }
8335            ios.precision(60);
8336            {
8337                nouppercase(ios);
8338                {
8339                    noshowpos(ios);
8340                    {
8341                        noshowpoint(ios);
8342                        {
8343                            ios.imbue(lc);
8344                            {
8345                                ios.width(0);
8346                                {
8347                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8348                                    std::string ex(str, iter.base());
8349                                    assert(ex == "1234567890.125");
8350                                    assert(ios.width() == 0);
8351                                }
8352                                ios.width(25);
8353                                left(ios);
8354                                {
8355                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8356                                    std::string ex(str, iter.base());
8357                                    assert(ex == "1234567890.125***********");
8358                                    assert(ios.width() == 0);
8359                                }
8360                                ios.width(25);
8361                                right(ios);
8362                                {
8363                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8364                                    std::string ex(str, iter.base());
8365                                    assert(ex == "***********1234567890.125");
8366                                    assert(ios.width() == 0);
8367                                }
8368                                ios.width(25);
8369                                internal(ios);
8370                                {
8371                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8372                                    std::string ex(str, iter.base());
8373                                    assert(ex == "***********1234567890.125");
8374                                    assert(ios.width() == 0);
8375                                }
8376                            }
8377                            ios.imbue(lg);
8378                            {
8379                                ios.width(0);
8380                                {
8381                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8382                                    std::string ex(str, iter.base());
8383                                    assert(ex == "1_234_567_89_0;125");
8384                                    assert(ios.width() == 0);
8385                                }
8386                                ios.width(25);
8387                                left(ios);
8388                                {
8389                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8390                                    std::string ex(str, iter.base());
8391                                    assert(ex == "1_234_567_89_0;125*******");
8392                                    assert(ios.width() == 0);
8393                                }
8394                                ios.width(25);
8395                                right(ios);
8396                                {
8397                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8398                                    std::string ex(str, iter.base());
8399                                    assert(ex == "*******1_234_567_89_0;125");
8400                                    assert(ios.width() == 0);
8401                                }
8402                                ios.width(25);
8403                                internal(ios);
8404                                {
8405                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8406                                    std::string ex(str, iter.base());
8407                                    assert(ex == "*******1_234_567_89_0;125");
8408                                    assert(ios.width() == 0);
8409                                }
8410                            }
8411                        }
8412                        showpoint(ios);
8413                        {
8414                            ios.imbue(lc);
8415                            {
8416                                ios.width(0);
8417                                {
8418                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8419                                    std::string ex(str, iter.base());
8420                                    assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8421                                    assert(ios.width() == 0);
8422                                }
8423                                ios.width(25);
8424                                left(ios);
8425                                {
8426                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8427                                    std::string ex(str, iter.base());
8428                                    assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8429                                    assert(ios.width() == 0);
8430                                }
8431                                ios.width(25);
8432                                right(ios);
8433                                {
8434                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8435                                    std::string ex(str, iter.base());
8436                                    assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8437                                    assert(ios.width() == 0);
8438                                }
8439                                ios.width(25);
8440                                internal(ios);
8441                                {
8442                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8443                                    std::string ex(str, iter.base());
8444                                    assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8445                                    assert(ios.width() == 0);
8446                                }
8447                            }
8448                            ios.imbue(lg);
8449                            {
8450                                ios.width(0);
8451                                {
8452                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8453                                    std::string ex(str, iter.base());
8454                                    assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8455                                    assert(ios.width() == 0);
8456                                }
8457                                ios.width(25);
8458                                left(ios);
8459                                {
8460                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8461                                    std::string ex(str, iter.base());
8462                                    assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8463                                    assert(ios.width() == 0);
8464                                }
8465                                ios.width(25);
8466                                right(ios);
8467                                {
8468                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8469                                    std::string ex(str, iter.base());
8470                                    assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8471                                    assert(ios.width() == 0);
8472                                }
8473                                ios.width(25);
8474                                internal(ios);
8475                                {
8476                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8477                                    std::string ex(str, iter.base());
8478                                    assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8479                                    assert(ios.width() == 0);
8480                                }
8481                            }
8482                        }
8483                    }
8484                    showpos(ios);
8485                    {
8486                        noshowpoint(ios);
8487                        {
8488                            ios.imbue(lc);
8489                            {
8490                                ios.width(0);
8491                                {
8492                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8493                                    std::string ex(str, iter.base());
8494                                    assert(ex == "+1234567890.125");
8495                                    assert(ios.width() == 0);
8496                                }
8497                                ios.width(25);
8498                                left(ios);
8499                                {
8500                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8501                                    std::string ex(str, iter.base());
8502                                    assert(ex == "+1234567890.125**********");
8503                                    assert(ios.width() == 0);
8504                                }
8505                                ios.width(25);
8506                                right(ios);
8507                                {
8508                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8509                                    std::string ex(str, iter.base());
8510                                    assert(ex == "**********+1234567890.125");
8511                                    assert(ios.width() == 0);
8512                                }
8513                                ios.width(25);
8514                                internal(ios);
8515                                {
8516                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8517                                    std::string ex(str, iter.base());
8518                                    assert(ex == "+**********1234567890.125");
8519                                    assert(ios.width() == 0);
8520                                }
8521                            }
8522                            ios.imbue(lg);
8523                            {
8524                                ios.width(0);
8525                                {
8526                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8527                                    std::string ex(str, iter.base());
8528                                    assert(ex == "+1_234_567_89_0;125");
8529                                    assert(ios.width() == 0);
8530                                }
8531                                ios.width(25);
8532                                left(ios);
8533                                {
8534                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8535                                    std::string ex(str, iter.base());
8536                                    assert(ex == "+1_234_567_89_0;125******");
8537                                    assert(ios.width() == 0);
8538                                }
8539                                ios.width(25);
8540                                right(ios);
8541                                {
8542                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8543                                    std::string ex(str, iter.base());
8544                                    assert(ex == "******+1_234_567_89_0;125");
8545                                    assert(ios.width() == 0);
8546                                }
8547                                ios.width(25);
8548                                internal(ios);
8549                                {
8550                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8551                                    std::string ex(str, iter.base());
8552                                    assert(ex == "+******1_234_567_89_0;125");
8553                                    assert(ios.width() == 0);
8554                                }
8555                            }
8556                        }
8557                        showpoint(ios);
8558                        {
8559                            ios.imbue(lc);
8560                            {
8561                                ios.width(0);
8562                                {
8563                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8564                                    std::string ex(str, iter.base());
8565                                    assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8566                                    assert(ios.width() == 0);
8567                                }
8568                                ios.width(25);
8569                                left(ios);
8570                                {
8571                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8572                                    std::string ex(str, iter.base());
8573                                    assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8574                                    assert(ios.width() == 0);
8575                                }
8576                                ios.width(25);
8577                                right(ios);
8578                                {
8579                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8580                                    std::string ex(str, iter.base());
8581                                    assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8582                                    assert(ios.width() == 0);
8583                                }
8584                                ios.width(25);
8585                                internal(ios);
8586                                {
8587                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8588                                    std::string ex(str, iter.base());
8589                                    assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8590                                    assert(ios.width() == 0);
8591                                }
8592                            }
8593                            ios.imbue(lg);
8594                            {
8595                                ios.width(0);
8596                                {
8597                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8598                                    std::string ex(str, iter.base());
8599                                    assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8600                                    assert(ios.width() == 0);
8601                                }
8602                                ios.width(25);
8603                                left(ios);
8604                                {
8605                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8606                                    std::string ex(str, iter.base());
8607                                    assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8608                                    assert(ios.width() == 0);
8609                                }
8610                                ios.width(25);
8611                                right(ios);
8612                                {
8613                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8614                                    std::string ex(str, iter.base());
8615                                    assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8616                                    assert(ios.width() == 0);
8617                                }
8618                                ios.width(25);
8619                                internal(ios);
8620                                {
8621                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8622                                    std::string ex(str, iter.base());
8623                                    assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8624                                    assert(ios.width() == 0);
8625                                }
8626                            }
8627                        }
8628                    }
8629                }
8630                uppercase(ios);
8631                {
8632                    noshowpos(ios);
8633                    {
8634                        noshowpoint(ios);
8635                        {
8636                            ios.imbue(lc);
8637                            {
8638                                ios.width(0);
8639                                {
8640                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8641                                    std::string ex(str, iter.base());
8642                                    assert(ex == "1234567890.125");
8643                                    assert(ios.width() == 0);
8644                                }
8645                                ios.width(25);
8646                                left(ios);
8647                                {
8648                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8649                                    std::string ex(str, iter.base());
8650                                    assert(ex == "1234567890.125***********");
8651                                    assert(ios.width() == 0);
8652                                }
8653                                ios.width(25);
8654                                right(ios);
8655                                {
8656                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8657                                    std::string ex(str, iter.base());
8658                                    assert(ex == "***********1234567890.125");
8659                                    assert(ios.width() == 0);
8660                                }
8661                                ios.width(25);
8662                                internal(ios);
8663                                {
8664                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8665                                    std::string ex(str, iter.base());
8666                                    assert(ex == "***********1234567890.125");
8667                                    assert(ios.width() == 0);
8668                                }
8669                            }
8670                            ios.imbue(lg);
8671                            {
8672                                ios.width(0);
8673                                {
8674                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8675                                    std::string ex(str, iter.base());
8676                                    assert(ex == "1_234_567_89_0;125");
8677                                    assert(ios.width() == 0);
8678                                }
8679                                ios.width(25);
8680                                left(ios);
8681                                {
8682                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8683                                    std::string ex(str, iter.base());
8684                                    assert(ex == "1_234_567_89_0;125*******");
8685                                    assert(ios.width() == 0);
8686                                }
8687                                ios.width(25);
8688                                right(ios);
8689                                {
8690                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8691                                    std::string ex(str, iter.base());
8692                                    assert(ex == "*******1_234_567_89_0;125");
8693                                    assert(ios.width() == 0);
8694                                }
8695                                ios.width(25);
8696                                internal(ios);
8697                                {
8698                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8699                                    std::string ex(str, iter.base());
8700                                    assert(ex == "*******1_234_567_89_0;125");
8701                                    assert(ios.width() == 0);
8702                                }
8703                            }
8704                        }
8705                        showpoint(ios);
8706                        {
8707                            ios.imbue(lc);
8708                            {
8709                                ios.width(0);
8710                                {
8711                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8712                                    std::string ex(str, iter.base());
8713                                    assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8714                                    assert(ios.width() == 0);
8715                                }
8716                                ios.width(25);
8717                                left(ios);
8718                                {
8719                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8720                                    std::string ex(str, iter.base());
8721                                    assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8722                                    assert(ios.width() == 0);
8723                                }
8724                                ios.width(25);
8725                                right(ios);
8726                                {
8727                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8728                                    std::string ex(str, iter.base());
8729                                    assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8730                                    assert(ios.width() == 0);
8731                                }
8732                                ios.width(25);
8733                                internal(ios);
8734                                {
8735                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8736                                    std::string ex(str, iter.base());
8737                                    assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
8738                                    assert(ios.width() == 0);
8739                                }
8740                            }
8741                            ios.imbue(lg);
8742                            {
8743                                ios.width(0);
8744                                {
8745                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8746                                    std::string ex(str, iter.base());
8747                                    assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8748                                    assert(ios.width() == 0);
8749                                }
8750                                ios.width(25);
8751                                left(ios);
8752                                {
8753                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8754                                    std::string ex(str, iter.base());
8755                                    assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8756                                    assert(ios.width() == 0);
8757                                }
8758                                ios.width(25);
8759                                right(ios);
8760                                {
8761                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8762                                    std::string ex(str, iter.base());
8763                                    assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8764                                    assert(ios.width() == 0);
8765                                }
8766                                ios.width(25);
8767                                internal(ios);
8768                                {
8769                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8770                                    std::string ex(str, iter.base());
8771                                    assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8772                                    assert(ios.width() == 0);
8773                                }
8774                            }
8775                        }
8776                    }
8777                    showpos(ios);
8778                    {
8779                        noshowpoint(ios);
8780                        {
8781                            ios.imbue(lc);
8782                            {
8783                                ios.width(0);
8784                                {
8785                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8786                                    std::string ex(str, iter.base());
8787                                    assert(ex == "+1234567890.125");
8788                                    assert(ios.width() == 0);
8789                                }
8790                                ios.width(25);
8791                                left(ios);
8792                                {
8793                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8794                                    std::string ex(str, iter.base());
8795                                    assert(ex == "+1234567890.125**********");
8796                                    assert(ios.width() == 0);
8797                                }
8798                                ios.width(25);
8799                                right(ios);
8800                                {
8801                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8802                                    std::string ex(str, iter.base());
8803                                    assert(ex == "**********+1234567890.125");
8804                                    assert(ios.width() == 0);
8805                                }
8806                                ios.width(25);
8807                                internal(ios);
8808                                {
8809                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8810                                    std::string ex(str, iter.base());
8811                                    assert(ex == "+**********1234567890.125");
8812                                    assert(ios.width() == 0);
8813                                }
8814                            }
8815                            ios.imbue(lg);
8816                            {
8817                                ios.width(0);
8818                                {
8819                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8820                                    std::string ex(str, iter.base());
8821                                    assert(ex == "+1_234_567_89_0;125");
8822                                    assert(ios.width() == 0);
8823                                }
8824                                ios.width(25);
8825                                left(ios);
8826                                {
8827                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8828                                    std::string ex(str, iter.base());
8829                                    assert(ex == "+1_234_567_89_0;125******");
8830                                    assert(ios.width() == 0);
8831                                }
8832                                ios.width(25);
8833                                right(ios);
8834                                {
8835                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8836                                    std::string ex(str, iter.base());
8837                                    assert(ex == "******+1_234_567_89_0;125");
8838                                    assert(ios.width() == 0);
8839                                }
8840                                ios.width(25);
8841                                internal(ios);
8842                                {
8843                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8844                                    std::string ex(str, iter.base());
8845                                    assert(ex == "+******1_234_567_89_0;125");
8846                                    assert(ios.width() == 0);
8847                                }
8848                            }
8849                        }
8850                        showpoint(ios);
8851                        {
8852                            ios.imbue(lc);
8853                            {
8854                                ios.width(0);
8855                                {
8856                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8857                                    std::string ex(str, iter.base());
8858                                    assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8859                                    assert(ios.width() == 0);
8860                                }
8861                                ios.width(25);
8862                                left(ios);
8863                                {
8864                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8865                                    std::string ex(str, iter.base());
8866                                    assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8867                                    assert(ios.width() == 0);
8868                                }
8869                                ios.width(25);
8870                                right(ios);
8871                                {
8872                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8873                                    std::string ex(str, iter.base());
8874                                    assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8875                                    assert(ios.width() == 0);
8876                                }
8877                                ios.width(25);
8878                                internal(ios);
8879                                {
8880                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8881                                    std::string ex(str, iter.base());
8882                                    assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
8883                                    assert(ios.width() == 0);
8884                                }
8885                            }
8886                            ios.imbue(lg);
8887                            {
8888                                ios.width(0);
8889                                {
8890                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8891                                    std::string ex(str, iter.base());
8892                                    assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8893                                    assert(ios.width() == 0);
8894                                }
8895                                ios.width(25);
8896                                left(ios);
8897                                {
8898                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8899                                    std::string ex(str, iter.base());
8900                                    assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8901                                    assert(ios.width() == 0);
8902                                }
8903                                ios.width(25);
8904                                right(ios);
8905                                {
8906                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8907                                    std::string ex(str, iter.base());
8908                                    assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8909                                    assert(ios.width() == 0);
8910                                }
8911                                ios.width(25);
8912                                internal(ios);
8913                                {
8914                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8915                                    std::string ex(str, iter.base());
8916                                    assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
8917                                    assert(ios.width() == 0);
8918                                }
8919                            }
8920                        }
8921                    }
8922                }
8923            }
8924        }
8925    }
8926}
8927
8928void test4()
8929{
8930    char str[200];
8931    output_iterator<char*> iter;
8932    std::locale lc = std::locale::classic();
8933    std::locale lg(lc, new my_numpunct);
8934    const my_facet f(1);
8935    {
8936        long double v = -INFINITY;
8937        std::ios ios(0);
8938        // %g
8939        {
8940            ios.precision(0);
8941            {
8942                nouppercase(ios);
8943                {
8944                    noshowpos(ios);
8945                    {
8946                        noshowpoint(ios);
8947                        {
8948                            ios.imbue(lc);
8949                            {
8950                                ios.width(0);
8951                                {
8952                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8953                                    std::string ex(str, iter.base());
8954                                    assert(ex == "-inf");
8955                                    assert(ios.width() == 0);
8956                                }
8957                                ios.width(25);
8958                                left(ios);
8959                                {
8960                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8961                                    std::string ex(str, iter.base());
8962                                    assert(ex == "-inf*********************");
8963                                    assert(ios.width() == 0);
8964                                }
8965                                ios.width(25);
8966                                right(ios);
8967                                {
8968                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8969                                    std::string ex(str, iter.base());
8970                                    assert(ex == "*********************-inf");
8971                                    assert(ios.width() == 0);
8972                                }
8973                                ios.width(25);
8974                                internal(ios);
8975                                {
8976                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8977                                    std::string ex(str, iter.base());
8978                                    assert(ex == "-*********************inf");
8979                                    assert(ios.width() == 0);
8980                                }
8981                            }
8982                            ios.imbue(lg);
8983                            {
8984                                ios.width(0);
8985                                {
8986                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8987                                    std::string ex(str, iter.base());
8988                                    assert(ex == "-inf");
8989                                    assert(ios.width() == 0);
8990                                }
8991                                ios.width(25);
8992                                left(ios);
8993                                {
8994                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
8995                                    std::string ex(str, iter.base());
8996                                    assert(ex == "-inf*********************");
8997                                    assert(ios.width() == 0);
8998                                }
8999                                ios.width(25);
9000                                right(ios);
9001                                {
9002                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9003                                    std::string ex(str, iter.base());
9004                                    assert(ex == "*********************-inf");
9005                                    assert(ios.width() == 0);
9006                                }
9007                                ios.width(25);
9008                                internal(ios);
9009                                {
9010                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9011                                    std::string ex(str, iter.base());
9012                                    assert(ex == "-*********************inf");
9013                                    assert(ios.width() == 0);
9014                                }
9015                            }
9016                        }
9017                        showpoint(ios);
9018                        {
9019                            ios.imbue(lc);
9020                            {
9021                                ios.width(0);
9022                                {
9023                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9024                                    std::string ex(str, iter.base());
9025                                    assert(ex == "-inf");
9026                                    assert(ios.width() == 0);
9027                                }
9028                                ios.width(25);
9029                                left(ios);
9030                                {
9031                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9032                                    std::string ex(str, iter.base());
9033                                    assert(ex == "-inf*********************");
9034                                    assert(ios.width() == 0);
9035                                }
9036                                ios.width(25);
9037                                right(ios);
9038                                {
9039                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9040                                    std::string ex(str, iter.base());
9041                                    assert(ex == "*********************-inf");
9042                                    assert(ios.width() == 0);
9043                                }
9044                                ios.width(25);
9045                                internal(ios);
9046                                {
9047                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9048                                    std::string ex(str, iter.base());
9049                                    assert(ex == "-*********************inf");
9050                                    assert(ios.width() == 0);
9051                                }
9052                            }
9053                            ios.imbue(lg);
9054                            {
9055                                ios.width(0);
9056                                {
9057                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9058                                    std::string ex(str, iter.base());
9059                                    assert(ex == "-inf");
9060                                    assert(ios.width() == 0);
9061                                }
9062                                ios.width(25);
9063                                left(ios);
9064                                {
9065                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9066                                    std::string ex(str, iter.base());
9067                                    assert(ex == "-inf*********************");
9068                                    assert(ios.width() == 0);
9069                                }
9070                                ios.width(25);
9071                                right(ios);
9072                                {
9073                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9074                                    std::string ex(str, iter.base());
9075                                    assert(ex == "*********************-inf");
9076                                    assert(ios.width() == 0);
9077                                }
9078                                ios.width(25);
9079                                internal(ios);
9080                                {
9081                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9082                                    std::string ex(str, iter.base());
9083                                    assert(ex == "-*********************inf");
9084                                    assert(ios.width() == 0);
9085                                }
9086                            }
9087                        }
9088                    }
9089                    showpos(ios);
9090                    {
9091                        noshowpoint(ios);
9092                        {
9093                            ios.imbue(lc);
9094                            {
9095                                ios.width(0);
9096                                {
9097                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9098                                    std::string ex(str, iter.base());
9099                                    assert(ex == "-inf");
9100                                    assert(ios.width() == 0);
9101                                }
9102                                ios.width(25);
9103                                left(ios);
9104                                {
9105                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9106                                    std::string ex(str, iter.base());
9107                                    assert(ex == "-inf*********************");
9108                                    assert(ios.width() == 0);
9109                                }
9110                                ios.width(25);
9111                                right(ios);
9112                                {
9113                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9114                                    std::string ex(str, iter.base());
9115                                    assert(ex == "*********************-inf");
9116                                    assert(ios.width() == 0);
9117                                }
9118                                ios.width(25);
9119                                internal(ios);
9120                                {
9121                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9122                                    std::string ex(str, iter.base());
9123                                    assert(ex == "-*********************inf");
9124                                    assert(ios.width() == 0);
9125                                }
9126                            }
9127                            ios.imbue(lg);
9128                            {
9129                                ios.width(0);
9130                                {
9131                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9132                                    std::string ex(str, iter.base());
9133                                    assert(ex == "-inf");
9134                                    assert(ios.width() == 0);
9135                                }
9136                                ios.width(25);
9137                                left(ios);
9138                                {
9139                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9140                                    std::string ex(str, iter.base());
9141                                    assert(ex == "-inf*********************");
9142                                    assert(ios.width() == 0);
9143                                }
9144                                ios.width(25);
9145                                right(ios);
9146                                {
9147                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9148                                    std::string ex(str, iter.base());
9149                                    assert(ex == "*********************-inf");
9150                                    assert(ios.width() == 0);
9151                                }
9152                                ios.width(25);
9153                                internal(ios);
9154                                {
9155                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9156                                    std::string ex(str, iter.base());
9157                                    assert(ex == "-*********************inf");
9158                                    assert(ios.width() == 0);
9159                                }
9160                            }
9161                        }
9162                        showpoint(ios);
9163                        {
9164                            ios.imbue(lc);
9165                            {
9166                                ios.width(0);
9167                                {
9168                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9169                                    std::string ex(str, iter.base());
9170                                    assert(ex == "-inf");
9171                                    assert(ios.width() == 0);
9172                                }
9173                                ios.width(25);
9174                                left(ios);
9175                                {
9176                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9177                                    std::string ex(str, iter.base());
9178                                    assert(ex == "-inf*********************");
9179                                    assert(ios.width() == 0);
9180                                }
9181                                ios.width(25);
9182                                right(ios);
9183                                {
9184                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9185                                    std::string ex(str, iter.base());
9186                                    assert(ex == "*********************-inf");
9187                                    assert(ios.width() == 0);
9188                                }
9189                                ios.width(25);
9190                                internal(ios);
9191                                {
9192                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9193                                    std::string ex(str, iter.base());
9194                                    assert(ex == "-*********************inf");
9195                                    assert(ios.width() == 0);
9196                                }
9197                            }
9198                            ios.imbue(lg);
9199                            {
9200                                ios.width(0);
9201                                {
9202                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9203                                    std::string ex(str, iter.base());
9204                                    assert(ex == "-inf");
9205                                    assert(ios.width() == 0);
9206                                }
9207                                ios.width(25);
9208                                left(ios);
9209                                {
9210                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9211                                    std::string ex(str, iter.base());
9212                                    assert(ex == "-inf*********************");
9213                                    assert(ios.width() == 0);
9214                                }
9215                                ios.width(25);
9216                                right(ios);
9217                                {
9218                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9219                                    std::string ex(str, iter.base());
9220                                    assert(ex == "*********************-inf");
9221                                    assert(ios.width() == 0);
9222                                }
9223                                ios.width(25);
9224                                internal(ios);
9225                                {
9226                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9227                                    std::string ex(str, iter.base());
9228                                    assert(ex == "-*********************inf");
9229                                    assert(ios.width() == 0);
9230                                }
9231                            }
9232                        }
9233                    }
9234                }
9235                uppercase(ios);
9236                {
9237                    noshowpos(ios);
9238                    {
9239                        noshowpoint(ios);
9240                        {
9241                            ios.imbue(lc);
9242                            {
9243                                ios.width(0);
9244                                {
9245                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9246                                    std::string ex(str, iter.base());
9247                                    assert(ex == "-INF");
9248                                    assert(ios.width() == 0);
9249                                }
9250                                ios.width(25);
9251                                left(ios);
9252                                {
9253                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9254                                    std::string ex(str, iter.base());
9255                                    assert(ex == "-INF*********************");
9256                                    assert(ios.width() == 0);
9257                                }
9258                                ios.width(25);
9259                                right(ios);
9260                                {
9261                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9262                                    std::string ex(str, iter.base());
9263                                    assert(ex == "*********************-INF");
9264                                    assert(ios.width() == 0);
9265                                }
9266                                ios.width(25);
9267                                internal(ios);
9268                                {
9269                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9270                                    std::string ex(str, iter.base());
9271                                    assert(ex == "-*********************INF");
9272                                    assert(ios.width() == 0);
9273                                }
9274                            }
9275                            ios.imbue(lg);
9276                            {
9277                                ios.width(0);
9278                                {
9279                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9280                                    std::string ex(str, iter.base());
9281                                    assert(ex == "-INF");
9282                                    assert(ios.width() == 0);
9283                                }
9284                                ios.width(25);
9285                                left(ios);
9286                                {
9287                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9288                                    std::string ex(str, iter.base());
9289                                    assert(ex == "-INF*********************");
9290                                    assert(ios.width() == 0);
9291                                }
9292                                ios.width(25);
9293                                right(ios);
9294                                {
9295                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9296                                    std::string ex(str, iter.base());
9297                                    assert(ex == "*********************-INF");
9298                                    assert(ios.width() == 0);
9299                                }
9300                                ios.width(25);
9301                                internal(ios);
9302                                {
9303                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9304                                    std::string ex(str, iter.base());
9305                                    assert(ex == "-*********************INF");
9306                                    assert(ios.width() == 0);
9307                                }
9308                            }
9309                        }
9310                        showpoint(ios);
9311                        {
9312                            ios.imbue(lc);
9313                            {
9314                                ios.width(0);
9315                                {
9316                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9317                                    std::string ex(str, iter.base());
9318                                    assert(ex == "-INF");
9319                                    assert(ios.width() == 0);
9320                                }
9321                                ios.width(25);
9322                                left(ios);
9323                                {
9324                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9325                                    std::string ex(str, iter.base());
9326                                    assert(ex == "-INF*********************");
9327                                    assert(ios.width() == 0);
9328                                }
9329                                ios.width(25);
9330                                right(ios);
9331                                {
9332                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9333                                    std::string ex(str, iter.base());
9334                                    assert(ex == "*********************-INF");
9335                                    assert(ios.width() == 0);
9336                                }
9337                                ios.width(25);
9338                                internal(ios);
9339                                {
9340                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9341                                    std::string ex(str, iter.base());
9342                                    assert(ex == "-*********************INF");
9343                                    assert(ios.width() == 0);
9344                                }
9345                            }
9346                            ios.imbue(lg);
9347                            {
9348                                ios.width(0);
9349                                {
9350                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9351                                    std::string ex(str, iter.base());
9352                                    assert(ex == "-INF");
9353                                    assert(ios.width() == 0);
9354                                }
9355                                ios.width(25);
9356                                left(ios);
9357                                {
9358                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9359                                    std::string ex(str, iter.base());
9360                                    assert(ex == "-INF*********************");
9361                                    assert(ios.width() == 0);
9362                                }
9363                                ios.width(25);
9364                                right(ios);
9365                                {
9366                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9367                                    std::string ex(str, iter.base());
9368                                    assert(ex == "*********************-INF");
9369                                    assert(ios.width() == 0);
9370                                }
9371                                ios.width(25);
9372                                internal(ios);
9373                                {
9374                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9375                                    std::string ex(str, iter.base());
9376                                    assert(ex == "-*********************INF");
9377                                    assert(ios.width() == 0);
9378                                }
9379                            }
9380                        }
9381                    }
9382                    showpos(ios);
9383                    {
9384                        noshowpoint(ios);
9385                        {
9386                            ios.imbue(lc);
9387                            {
9388                                ios.width(0);
9389                                {
9390                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9391                                    std::string ex(str, iter.base());
9392                                    assert(ex == "-INF");
9393                                    assert(ios.width() == 0);
9394                                }
9395                                ios.width(25);
9396                                left(ios);
9397                                {
9398                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9399                                    std::string ex(str, iter.base());
9400                                    assert(ex == "-INF*********************");
9401                                    assert(ios.width() == 0);
9402                                }
9403                                ios.width(25);
9404                                right(ios);
9405                                {
9406                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9407                                    std::string ex(str, iter.base());
9408                                    assert(ex == "*********************-INF");
9409                                    assert(ios.width() == 0);
9410                                }
9411                                ios.width(25);
9412                                internal(ios);
9413                                {
9414                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9415                                    std::string ex(str, iter.base());
9416                                    assert(ex == "-*********************INF");
9417                                    assert(ios.width() == 0);
9418                                }
9419                            }
9420                            ios.imbue(lg);
9421                            {
9422                                ios.width(0);
9423                                {
9424                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9425                                    std::string ex(str, iter.base());
9426                                    assert(ex == "-INF");
9427                                    assert(ios.width() == 0);
9428                                }
9429                                ios.width(25);
9430                                left(ios);
9431                                {
9432                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9433                                    std::string ex(str, iter.base());
9434                                    assert(ex == "-INF*********************");
9435                                    assert(ios.width() == 0);
9436                                }
9437                                ios.width(25);
9438                                right(ios);
9439                                {
9440                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9441                                    std::string ex(str, iter.base());
9442                                    assert(ex == "*********************-INF");
9443                                    assert(ios.width() == 0);
9444                                }
9445                                ios.width(25);
9446                                internal(ios);
9447                                {
9448                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9449                                    std::string ex(str, iter.base());
9450                                    assert(ex == "-*********************INF");
9451                                    assert(ios.width() == 0);
9452                                }
9453                            }
9454                        }
9455                        showpoint(ios);
9456                        {
9457                            ios.imbue(lc);
9458                            {
9459                                ios.width(0);
9460                                {
9461                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9462                                    std::string ex(str, iter.base());
9463                                    assert(ex == "-INF");
9464                                    assert(ios.width() == 0);
9465                                }
9466                                ios.width(25);
9467                                left(ios);
9468                                {
9469                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9470                                    std::string ex(str, iter.base());
9471                                    assert(ex == "-INF*********************");
9472                                    assert(ios.width() == 0);
9473                                }
9474                                ios.width(25);
9475                                right(ios);
9476                                {
9477                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9478                                    std::string ex(str, iter.base());
9479                                    assert(ex == "*********************-INF");
9480                                    assert(ios.width() == 0);
9481                                }
9482                                ios.width(25);
9483                                internal(ios);
9484                                {
9485                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9486                                    std::string ex(str, iter.base());
9487                                    assert(ex == "-*********************INF");
9488                                    assert(ios.width() == 0);
9489                                }
9490                            }
9491                            ios.imbue(lg);
9492                            {
9493                                ios.width(0);
9494                                {
9495                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9496                                    std::string ex(str, iter.base());
9497                                    assert(ex == "-INF");
9498                                    assert(ios.width() == 0);
9499                                }
9500                                ios.width(25);
9501                                left(ios);
9502                                {
9503                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9504                                    std::string ex(str, iter.base());
9505                                    assert(ex == "-INF*********************");
9506                                    assert(ios.width() == 0);
9507                                }
9508                                ios.width(25);
9509                                right(ios);
9510                                {
9511                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9512                                    std::string ex(str, iter.base());
9513                                    assert(ex == "*********************-INF");
9514                                    assert(ios.width() == 0);
9515                                }
9516                                ios.width(25);
9517                                internal(ios);
9518                                {
9519                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9520                                    std::string ex(str, iter.base());
9521                                    assert(ex == "-*********************INF");
9522                                    assert(ios.width() == 0);
9523                                }
9524                            }
9525                        }
9526                    }
9527                }
9528            }
9529            ios.precision(1);
9530            {
9531                nouppercase(ios);
9532                {
9533                    noshowpos(ios);
9534                    {
9535                        noshowpoint(ios);
9536                        {
9537                            ios.imbue(lc);
9538                            {
9539                                ios.width(0);
9540                                {
9541                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9542                                    std::string ex(str, iter.base());
9543                                    assert(ex == "-inf");
9544                                    assert(ios.width() == 0);
9545                                }
9546                                ios.width(25);
9547                                left(ios);
9548                                {
9549                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9550                                    std::string ex(str, iter.base());
9551                                    assert(ex == "-inf*********************");
9552                                    assert(ios.width() == 0);
9553                                }
9554                                ios.width(25);
9555                                right(ios);
9556                                {
9557                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9558                                    std::string ex(str, iter.base());
9559                                    assert(ex == "*********************-inf");
9560                                    assert(ios.width() == 0);
9561                                }
9562                                ios.width(25);
9563                                internal(ios);
9564                                {
9565                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9566                                    std::string ex(str, iter.base());
9567                                    assert(ex == "-*********************inf");
9568                                    assert(ios.width() == 0);
9569                                }
9570                            }
9571                            ios.imbue(lg);
9572                            {
9573                                ios.width(0);
9574                                {
9575                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9576                                    std::string ex(str, iter.base());
9577                                    assert(ex == "-inf");
9578                                    assert(ios.width() == 0);
9579                                }
9580                                ios.width(25);
9581                                left(ios);
9582                                {
9583                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9584                                    std::string ex(str, iter.base());
9585                                    assert(ex == "-inf*********************");
9586                                    assert(ios.width() == 0);
9587                                }
9588                                ios.width(25);
9589                                right(ios);
9590                                {
9591                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9592                                    std::string ex(str, iter.base());
9593                                    assert(ex == "*********************-inf");
9594                                    assert(ios.width() == 0);
9595                                }
9596                                ios.width(25);
9597                                internal(ios);
9598                                {
9599                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9600                                    std::string ex(str, iter.base());
9601                                    assert(ex == "-*********************inf");
9602                                    assert(ios.width() == 0);
9603                                }
9604                            }
9605                        }
9606                        showpoint(ios);
9607                        {
9608                            ios.imbue(lc);
9609                            {
9610                                ios.width(0);
9611                                {
9612                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9613                                    std::string ex(str, iter.base());
9614                                    assert(ex == "-inf");
9615                                    assert(ios.width() == 0);
9616                                }
9617                                ios.width(25);
9618                                left(ios);
9619                                {
9620                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9621                                    std::string ex(str, iter.base());
9622                                    assert(ex == "-inf*********************");
9623                                    assert(ios.width() == 0);
9624                                }
9625                                ios.width(25);
9626                                right(ios);
9627                                {
9628                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9629                                    std::string ex(str, iter.base());
9630                                    assert(ex == "*********************-inf");
9631                                    assert(ios.width() == 0);
9632                                }
9633                                ios.width(25);
9634                                internal(ios);
9635                                {
9636                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9637                                    std::string ex(str, iter.base());
9638                                    assert(ex == "-*********************inf");
9639                                    assert(ios.width() == 0);
9640                                }
9641                            }
9642                            ios.imbue(lg);
9643                            {
9644                                ios.width(0);
9645                                {
9646                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9647                                    std::string ex(str, iter.base());
9648                                    assert(ex == "-inf");
9649                                    assert(ios.width() == 0);
9650                                }
9651                                ios.width(25);
9652                                left(ios);
9653                                {
9654                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9655                                    std::string ex(str, iter.base());
9656                                    assert(ex == "-inf*********************");
9657                                    assert(ios.width() == 0);
9658                                }
9659                                ios.width(25);
9660                                right(ios);
9661                                {
9662                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9663                                    std::string ex(str, iter.base());
9664                                    assert(ex == "*********************-inf");
9665                                    assert(ios.width() == 0);
9666                                }
9667                                ios.width(25);
9668                                internal(ios);
9669                                {
9670                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9671                                    std::string ex(str, iter.base());
9672                                    assert(ex == "-*********************inf");
9673                                    assert(ios.width() == 0);
9674                                }
9675                            }
9676                        }
9677                    }
9678                    showpos(ios);
9679                    {
9680                        noshowpoint(ios);
9681                        {
9682                            ios.imbue(lc);
9683                            {
9684                                ios.width(0);
9685                                {
9686                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9687                                    std::string ex(str, iter.base());
9688                                    assert(ex == "-inf");
9689                                    assert(ios.width() == 0);
9690                                }
9691                                ios.width(25);
9692                                left(ios);
9693                                {
9694                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9695                                    std::string ex(str, iter.base());
9696                                    assert(ex == "-inf*********************");
9697                                    assert(ios.width() == 0);
9698                                }
9699                                ios.width(25);
9700                                right(ios);
9701                                {
9702                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9703                                    std::string ex(str, iter.base());
9704                                    assert(ex == "*********************-inf");
9705                                    assert(ios.width() == 0);
9706                                }
9707                                ios.width(25);
9708                                internal(ios);
9709                                {
9710                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9711                                    std::string ex(str, iter.base());
9712                                    assert(ex == "-*********************inf");
9713                                    assert(ios.width() == 0);
9714                                }
9715                            }
9716                            ios.imbue(lg);
9717                            {
9718                                ios.width(0);
9719                                {
9720                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9721                                    std::string ex(str, iter.base());
9722                                    assert(ex == "-inf");
9723                                    assert(ios.width() == 0);
9724                                }
9725                                ios.width(25);
9726                                left(ios);
9727                                {
9728                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9729                                    std::string ex(str, iter.base());
9730                                    assert(ex == "-inf*********************");
9731                                    assert(ios.width() == 0);
9732                                }
9733                                ios.width(25);
9734                                right(ios);
9735                                {
9736                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9737                                    std::string ex(str, iter.base());
9738                                    assert(ex == "*********************-inf");
9739                                    assert(ios.width() == 0);
9740                                }
9741                                ios.width(25);
9742                                internal(ios);
9743                                {
9744                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9745                                    std::string ex(str, iter.base());
9746                                    assert(ex == "-*********************inf");
9747                                    assert(ios.width() == 0);
9748                                }
9749                            }
9750                        }
9751                        showpoint(ios);
9752                        {
9753                            ios.imbue(lc);
9754                            {
9755                                ios.width(0);
9756                                {
9757                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9758                                    std::string ex(str, iter.base());
9759                                    assert(ex == "-inf");
9760                                    assert(ios.width() == 0);
9761                                }
9762                                ios.width(25);
9763                                left(ios);
9764                                {
9765                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9766                                    std::string ex(str, iter.base());
9767                                    assert(ex == "-inf*********************");
9768                                    assert(ios.width() == 0);
9769                                }
9770                                ios.width(25);
9771                                right(ios);
9772                                {
9773                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9774                                    std::string ex(str, iter.base());
9775                                    assert(ex == "*********************-inf");
9776                                    assert(ios.width() == 0);
9777                                }
9778                                ios.width(25);
9779                                internal(ios);
9780                                {
9781                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9782                                    std::string ex(str, iter.base());
9783                                    assert(ex == "-*********************inf");
9784                                    assert(ios.width() == 0);
9785                                }
9786                            }
9787                            ios.imbue(lg);
9788                            {
9789                                ios.width(0);
9790                                {
9791                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9792                                    std::string ex(str, iter.base());
9793                                    assert(ex == "-inf");
9794                                    assert(ios.width() == 0);
9795                                }
9796                                ios.width(25);
9797                                left(ios);
9798                                {
9799                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9800                                    std::string ex(str, iter.base());
9801                                    assert(ex == "-inf*********************");
9802                                    assert(ios.width() == 0);
9803                                }
9804                                ios.width(25);
9805                                right(ios);
9806                                {
9807                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9808                                    std::string ex(str, iter.base());
9809                                    assert(ex == "*********************-inf");
9810                                    assert(ios.width() == 0);
9811                                }
9812                                ios.width(25);
9813                                internal(ios);
9814                                {
9815                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9816                                    std::string ex(str, iter.base());
9817                                    assert(ex == "-*********************inf");
9818                                    assert(ios.width() == 0);
9819                                }
9820                            }
9821                        }
9822                    }
9823                }
9824                uppercase(ios);
9825                {
9826                    noshowpos(ios);
9827                    {
9828                        noshowpoint(ios);
9829                        {
9830                            ios.imbue(lc);
9831                            {
9832                                ios.width(0);
9833                                {
9834                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9835                                    std::string ex(str, iter.base());
9836                                    assert(ex == "-INF");
9837                                    assert(ios.width() == 0);
9838                                }
9839                                ios.width(25);
9840                                left(ios);
9841                                {
9842                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9843                                    std::string ex(str, iter.base());
9844                                    assert(ex == "-INF*********************");
9845                                    assert(ios.width() == 0);
9846                                }
9847                                ios.width(25);
9848                                right(ios);
9849                                {
9850                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9851                                    std::string ex(str, iter.base());
9852                                    assert(ex == "*********************-INF");
9853                                    assert(ios.width() == 0);
9854                                }
9855                                ios.width(25);
9856                                internal(ios);
9857                                {
9858                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9859                                    std::string ex(str, iter.base());
9860                                    assert(ex == "-*********************INF");
9861                                    assert(ios.width() == 0);
9862                                }
9863                            }
9864                            ios.imbue(lg);
9865                            {
9866                                ios.width(0);
9867                                {
9868                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9869                                    std::string ex(str, iter.base());
9870                                    assert(ex == "-INF");
9871                                    assert(ios.width() == 0);
9872                                }
9873                                ios.width(25);
9874                                left(ios);
9875                                {
9876                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9877                                    std::string ex(str, iter.base());
9878                                    assert(ex == "-INF*********************");
9879                                    assert(ios.width() == 0);
9880                                }
9881                                ios.width(25);
9882                                right(ios);
9883                                {
9884                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9885                                    std::string ex(str, iter.base());
9886                                    assert(ex == "*********************-INF");
9887                                    assert(ios.width() == 0);
9888                                }
9889                                ios.width(25);
9890                                internal(ios);
9891                                {
9892                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9893                                    std::string ex(str, iter.base());
9894                                    assert(ex == "-*********************INF");
9895                                    assert(ios.width() == 0);
9896                                }
9897                            }
9898                        }
9899                        showpoint(ios);
9900                        {
9901                            ios.imbue(lc);
9902                            {
9903                                ios.width(0);
9904                                {
9905                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9906                                    std::string ex(str, iter.base());
9907                                    assert(ex == "-INF");
9908                                    assert(ios.width() == 0);
9909                                }
9910                                ios.width(25);
9911                                left(ios);
9912                                {
9913                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9914                                    std::string ex(str, iter.base());
9915                                    assert(ex == "-INF*********************");
9916                                    assert(ios.width() == 0);
9917                                }
9918                                ios.width(25);
9919                                right(ios);
9920                                {
9921                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9922                                    std::string ex(str, iter.base());
9923                                    assert(ex == "*********************-INF");
9924                                    assert(ios.width() == 0);
9925                                }
9926                                ios.width(25);
9927                                internal(ios);
9928                                {
9929                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9930                                    std::string ex(str, iter.base());
9931                                    assert(ex == "-*********************INF");
9932                                    assert(ios.width() == 0);
9933                                }
9934                            }
9935                            ios.imbue(lg);
9936                            {
9937                                ios.width(0);
9938                                {
9939                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9940                                    std::string ex(str, iter.base());
9941                                    assert(ex == "-INF");
9942                                    assert(ios.width() == 0);
9943                                }
9944                                ios.width(25);
9945                                left(ios);
9946                                {
9947                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9948                                    std::string ex(str, iter.base());
9949                                    assert(ex == "-INF*********************");
9950                                    assert(ios.width() == 0);
9951                                }
9952                                ios.width(25);
9953                                right(ios);
9954                                {
9955                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9956                                    std::string ex(str, iter.base());
9957                                    assert(ex == "*********************-INF");
9958                                    assert(ios.width() == 0);
9959                                }
9960                                ios.width(25);
9961                                internal(ios);
9962                                {
9963                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9964                                    std::string ex(str, iter.base());
9965                                    assert(ex == "-*********************INF");
9966                                    assert(ios.width() == 0);
9967                                }
9968                            }
9969                        }
9970                    }
9971                    showpos(ios);
9972                    {
9973                        noshowpoint(ios);
9974                        {
9975                            ios.imbue(lc);
9976                            {
9977                                ios.width(0);
9978                                {
9979                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9980                                    std::string ex(str, iter.base());
9981                                    assert(ex == "-INF");
9982                                    assert(ios.width() == 0);
9983                                }
9984                                ios.width(25);
9985                                left(ios);
9986                                {
9987                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9988                                    std::string ex(str, iter.base());
9989                                    assert(ex == "-INF*********************");
9990                                    assert(ios.width() == 0);
9991                                }
9992                                ios.width(25);
9993                                right(ios);
9994                                {
9995                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
9996                                    std::string ex(str, iter.base());
9997                                    assert(ex == "*********************-INF");
9998                                    assert(ios.width() == 0);
9999                                }
10000                                ios.width(25);
10001                                internal(ios);
10002                                {
10003                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10004                                    std::string ex(str, iter.base());
10005                                    assert(ex == "-*********************INF");
10006                                    assert(ios.width() == 0);
10007                                }
10008                            }
10009                            ios.imbue(lg);
10010                            {
10011                                ios.width(0);
10012                                {
10013                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10014                                    std::string ex(str, iter.base());
10015                                    assert(ex == "-INF");
10016                                    assert(ios.width() == 0);
10017                                }
10018                                ios.width(25);
10019                                left(ios);
10020                                {
10021                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10022                                    std::string ex(str, iter.base());
10023                                    assert(ex == "-INF*********************");
10024                                    assert(ios.width() == 0);
10025                                }
10026                                ios.width(25);
10027                                right(ios);
10028                                {
10029                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10030                                    std::string ex(str, iter.base());
10031                                    assert(ex == "*********************-INF");
10032                                    assert(ios.width() == 0);
10033                                }
10034                                ios.width(25);
10035                                internal(ios);
10036                                {
10037                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10038                                    std::string ex(str, iter.base());
10039                                    assert(ex == "-*********************INF");
10040                                    assert(ios.width() == 0);
10041                                }
10042                            }
10043                        }
10044                        showpoint(ios);
10045                        {
10046                            ios.imbue(lc);
10047                            {
10048                                ios.width(0);
10049                                {
10050                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10051                                    std::string ex(str, iter.base());
10052                                    assert(ex == "-INF");
10053                                    assert(ios.width() == 0);
10054                                }
10055                                ios.width(25);
10056                                left(ios);
10057                                {
10058                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10059                                    std::string ex(str, iter.base());
10060                                    assert(ex == "-INF*********************");
10061                                    assert(ios.width() == 0);
10062                                }
10063                                ios.width(25);
10064                                right(ios);
10065                                {
10066                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10067                                    std::string ex(str, iter.base());
10068                                    assert(ex == "*********************-INF");
10069                                    assert(ios.width() == 0);
10070                                }
10071                                ios.width(25);
10072                                internal(ios);
10073                                {
10074                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10075                                    std::string ex(str, iter.base());
10076                                    assert(ex == "-*********************INF");
10077                                    assert(ios.width() == 0);
10078                                }
10079                            }
10080                            ios.imbue(lg);
10081                            {
10082                                ios.width(0);
10083                                {
10084                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10085                                    std::string ex(str, iter.base());
10086                                    assert(ex == "-INF");
10087                                    assert(ios.width() == 0);
10088                                }
10089                                ios.width(25);
10090                                left(ios);
10091                                {
10092                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10093                                    std::string ex(str, iter.base());
10094                                    assert(ex == "-INF*********************");
10095                                    assert(ios.width() == 0);
10096                                }
10097                                ios.width(25);
10098                                right(ios);
10099                                {
10100                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10101                                    std::string ex(str, iter.base());
10102                                    assert(ex == "*********************-INF");
10103                                    assert(ios.width() == 0);
10104                                }
10105                                ios.width(25);
10106                                internal(ios);
10107                                {
10108                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10109                                    std::string ex(str, iter.base());
10110                                    assert(ex == "-*********************INF");
10111                                    assert(ios.width() == 0);
10112                                }
10113                            }
10114                        }
10115                    }
10116                }
10117            }
10118            ios.precision(6);
10119            {
10120                nouppercase(ios);
10121                {
10122                    noshowpos(ios);
10123                    {
10124                        noshowpoint(ios);
10125                        {
10126                            ios.imbue(lc);
10127                            {
10128                                ios.width(0);
10129                                {
10130                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10131                                    std::string ex(str, iter.base());
10132                                    assert(ex == "-inf");
10133                                    assert(ios.width() == 0);
10134                                }
10135                                ios.width(25);
10136                                left(ios);
10137                                {
10138                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10139                                    std::string ex(str, iter.base());
10140                                    assert(ex == "-inf*********************");
10141                                    assert(ios.width() == 0);
10142                                }
10143                                ios.width(25);
10144                                right(ios);
10145                                {
10146                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10147                                    std::string ex(str, iter.base());
10148                                    assert(ex == "*********************-inf");
10149                                    assert(ios.width() == 0);
10150                                }
10151                                ios.width(25);
10152                                internal(ios);
10153                                {
10154                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10155                                    std::string ex(str, iter.base());
10156                                    assert(ex == "-*********************inf");
10157                                    assert(ios.width() == 0);
10158                                }
10159                            }
10160                            ios.imbue(lg);
10161                            {
10162                                ios.width(0);
10163                                {
10164                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10165                                    std::string ex(str, iter.base());
10166                                    assert(ex == "-inf");
10167                                    assert(ios.width() == 0);
10168                                }
10169                                ios.width(25);
10170                                left(ios);
10171                                {
10172                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10173                                    std::string ex(str, iter.base());
10174                                    assert(ex == "-inf*********************");
10175                                    assert(ios.width() == 0);
10176                                }
10177                                ios.width(25);
10178                                right(ios);
10179                                {
10180                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10181                                    std::string ex(str, iter.base());
10182                                    assert(ex == "*********************-inf");
10183                                    assert(ios.width() == 0);
10184                                }
10185                                ios.width(25);
10186                                internal(ios);
10187                                {
10188                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10189                                    std::string ex(str, iter.base());
10190                                    assert(ex == "-*********************inf");
10191                                    assert(ios.width() == 0);
10192                                }
10193                            }
10194                        }
10195                        showpoint(ios);
10196                        {
10197                            ios.imbue(lc);
10198                            {
10199                                ios.width(0);
10200                                {
10201                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10202                                    std::string ex(str, iter.base());
10203                                    assert(ex == "-inf");
10204                                    assert(ios.width() == 0);
10205                                }
10206                                ios.width(25);
10207                                left(ios);
10208                                {
10209                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10210                                    std::string ex(str, iter.base());
10211                                    assert(ex == "-inf*********************");
10212                                    assert(ios.width() == 0);
10213                                }
10214                                ios.width(25);
10215                                right(ios);
10216                                {
10217                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10218                                    std::string ex(str, iter.base());
10219                                    assert(ex == "*********************-inf");
10220                                    assert(ios.width() == 0);
10221                                }
10222                                ios.width(25);
10223                                internal(ios);
10224                                {
10225                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10226                                    std::string ex(str, iter.base());
10227                                    assert(ex == "-*********************inf");
10228                                    assert(ios.width() == 0);
10229                                }
10230                            }
10231                            ios.imbue(lg);
10232                            {
10233                                ios.width(0);
10234                                {
10235                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10236                                    std::string ex(str, iter.base());
10237                                    assert(ex == "-inf");
10238                                    assert(ios.width() == 0);
10239                                }
10240                                ios.width(25);
10241                                left(ios);
10242                                {
10243                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10244                                    std::string ex(str, iter.base());
10245                                    assert(ex == "-inf*********************");
10246                                    assert(ios.width() == 0);
10247                                }
10248                                ios.width(25);
10249                                right(ios);
10250                                {
10251                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10252                                    std::string ex(str, iter.base());
10253                                    assert(ex == "*********************-inf");
10254                                    assert(ios.width() == 0);
10255                                }
10256                                ios.width(25);
10257                                internal(ios);
10258                                {
10259                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10260                                    std::string ex(str, iter.base());
10261                                    assert(ex == "-*********************inf");
10262                                    assert(ios.width() == 0);
10263                                }
10264                            }
10265                        }
10266                    }
10267                    showpos(ios);
10268                    {
10269                        noshowpoint(ios);
10270                        {
10271                            ios.imbue(lc);
10272                            {
10273                                ios.width(0);
10274                                {
10275                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10276                                    std::string ex(str, iter.base());
10277                                    assert(ex == "-inf");
10278                                    assert(ios.width() == 0);
10279                                }
10280                                ios.width(25);
10281                                left(ios);
10282                                {
10283                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10284                                    std::string ex(str, iter.base());
10285                                    assert(ex == "-inf*********************");
10286                                    assert(ios.width() == 0);
10287                                }
10288                                ios.width(25);
10289                                right(ios);
10290                                {
10291                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10292                                    std::string ex(str, iter.base());
10293                                    assert(ex == "*********************-inf");
10294                                    assert(ios.width() == 0);
10295                                }
10296                                ios.width(25);
10297                                internal(ios);
10298                                {
10299                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10300                                    std::string ex(str, iter.base());
10301                                    assert(ex == "-*********************inf");
10302                                    assert(ios.width() == 0);
10303                                }
10304                            }
10305                            ios.imbue(lg);
10306                            {
10307                                ios.width(0);
10308                                {
10309                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10310                                    std::string ex(str, iter.base());
10311                                    assert(ex == "-inf");
10312                                    assert(ios.width() == 0);
10313                                }
10314                                ios.width(25);
10315                                left(ios);
10316                                {
10317                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10318                                    std::string ex(str, iter.base());
10319                                    assert(ex == "-inf*********************");
10320                                    assert(ios.width() == 0);
10321                                }
10322                                ios.width(25);
10323                                right(ios);
10324                                {
10325                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10326                                    std::string ex(str, iter.base());
10327                                    assert(ex == "*********************-inf");
10328                                    assert(ios.width() == 0);
10329                                }
10330                                ios.width(25);
10331                                internal(ios);
10332                                {
10333                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10334                                    std::string ex(str, iter.base());
10335                                    assert(ex == "-*********************inf");
10336                                    assert(ios.width() == 0);
10337                                }
10338                            }
10339                        }
10340                        showpoint(ios);
10341                        {
10342                            ios.imbue(lc);
10343                            {
10344                                ios.width(0);
10345                                {
10346                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10347                                    std::string ex(str, iter.base());
10348                                    assert(ex == "-inf");
10349                                    assert(ios.width() == 0);
10350                                }
10351                                ios.width(25);
10352                                left(ios);
10353                                {
10354                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10355                                    std::string ex(str, iter.base());
10356                                    assert(ex == "-inf*********************");
10357                                    assert(ios.width() == 0);
10358                                }
10359                                ios.width(25);
10360                                right(ios);
10361                                {
10362                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10363                                    std::string ex(str, iter.base());
10364                                    assert(ex == "*********************-inf");
10365                                    assert(ios.width() == 0);
10366                                }
10367                                ios.width(25);
10368                                internal(ios);
10369                                {
10370                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10371                                    std::string ex(str, iter.base());
10372                                    assert(ex == "-*********************inf");
10373                                    assert(ios.width() == 0);
10374                                }
10375                            }
10376                            ios.imbue(lg);
10377                            {
10378                                ios.width(0);
10379                                {
10380                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10381                                    std::string ex(str, iter.base());
10382                                    assert(ex == "-inf");
10383                                    assert(ios.width() == 0);
10384                                }
10385                                ios.width(25);
10386                                left(ios);
10387                                {
10388                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10389                                    std::string ex(str, iter.base());
10390                                    assert(ex == "-inf*********************");
10391                                    assert(ios.width() == 0);
10392                                }
10393                                ios.width(25);
10394                                right(ios);
10395                                {
10396                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10397                                    std::string ex(str, iter.base());
10398                                    assert(ex == "*********************-inf");
10399                                    assert(ios.width() == 0);
10400                                }
10401                                ios.width(25);
10402                                internal(ios);
10403                                {
10404                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10405                                    std::string ex(str, iter.base());
10406                                    assert(ex == "-*********************inf");
10407                                    assert(ios.width() == 0);
10408                                }
10409                            }
10410                        }
10411                    }
10412                }
10413                uppercase(ios);
10414                {
10415                    noshowpos(ios);
10416                    {
10417                        noshowpoint(ios);
10418                        {
10419                            ios.imbue(lc);
10420                            {
10421                                ios.width(0);
10422                                {
10423                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10424                                    std::string ex(str, iter.base());
10425                                    assert(ex == "-INF");
10426                                    assert(ios.width() == 0);
10427                                }
10428                                ios.width(25);
10429                                left(ios);
10430                                {
10431                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10432                                    std::string ex(str, iter.base());
10433                                    assert(ex == "-INF*********************");
10434                                    assert(ios.width() == 0);
10435                                }
10436                                ios.width(25);
10437                                right(ios);
10438                                {
10439                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10440                                    std::string ex(str, iter.base());
10441                                    assert(ex == "*********************-INF");
10442                                    assert(ios.width() == 0);
10443                                }
10444                                ios.width(25);
10445                                internal(ios);
10446                                {
10447                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10448                                    std::string ex(str, iter.base());
10449                                    assert(ex == "-*********************INF");
10450                                    assert(ios.width() == 0);
10451                                }
10452                            }
10453                            ios.imbue(lg);
10454                            {
10455                                ios.width(0);
10456                                {
10457                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10458                                    std::string ex(str, iter.base());
10459                                    assert(ex == "-INF");
10460                                    assert(ios.width() == 0);
10461                                }
10462                                ios.width(25);
10463                                left(ios);
10464                                {
10465                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10466                                    std::string ex(str, iter.base());
10467                                    assert(ex == "-INF*********************");
10468                                    assert(ios.width() == 0);
10469                                }
10470                                ios.width(25);
10471                                right(ios);
10472                                {
10473                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10474                                    std::string ex(str, iter.base());
10475                                    assert(ex == "*********************-INF");
10476                                    assert(ios.width() == 0);
10477                                }
10478                                ios.width(25);
10479                                internal(ios);
10480                                {
10481                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10482                                    std::string ex(str, iter.base());
10483                                    assert(ex == "-*********************INF");
10484                                    assert(ios.width() == 0);
10485                                }
10486                            }
10487                        }
10488                        showpoint(ios);
10489                        {
10490                            ios.imbue(lc);
10491                            {
10492                                ios.width(0);
10493                                {
10494                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10495                                    std::string ex(str, iter.base());
10496                                    assert(ex == "-INF");
10497                                    assert(ios.width() == 0);
10498                                }
10499                                ios.width(25);
10500                                left(ios);
10501                                {
10502                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10503                                    std::string ex(str, iter.base());
10504                                    assert(ex == "-INF*********************");
10505                                    assert(ios.width() == 0);
10506                                }
10507                                ios.width(25);
10508                                right(ios);
10509                                {
10510                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10511                                    std::string ex(str, iter.base());
10512                                    assert(ex == "*********************-INF");
10513                                    assert(ios.width() == 0);
10514                                }
10515                                ios.width(25);
10516                                internal(ios);
10517                                {
10518                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10519                                    std::string ex(str, iter.base());
10520                                    assert(ex == "-*********************INF");
10521                                    assert(ios.width() == 0);
10522                                }
10523                            }
10524                            ios.imbue(lg);
10525                            {
10526                                ios.width(0);
10527                                {
10528                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10529                                    std::string ex(str, iter.base());
10530                                    assert(ex == "-INF");
10531                                    assert(ios.width() == 0);
10532                                }
10533                                ios.width(25);
10534                                left(ios);
10535                                {
10536                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10537                                    std::string ex(str, iter.base());
10538                                    assert(ex == "-INF*********************");
10539                                    assert(ios.width() == 0);
10540                                }
10541                                ios.width(25);
10542                                right(ios);
10543                                {
10544                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10545                                    std::string ex(str, iter.base());
10546                                    assert(ex == "*********************-INF");
10547                                    assert(ios.width() == 0);
10548                                }
10549                                ios.width(25);
10550                                internal(ios);
10551                                {
10552                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10553                                    std::string ex(str, iter.base());
10554                                    assert(ex == "-*********************INF");
10555                                    assert(ios.width() == 0);
10556                                }
10557                            }
10558                        }
10559                    }
10560                    showpos(ios);
10561                    {
10562                        noshowpoint(ios);
10563                        {
10564                            ios.imbue(lc);
10565                            {
10566                                ios.width(0);
10567                                {
10568                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10569                                    std::string ex(str, iter.base());
10570                                    assert(ex == "-INF");
10571                                    assert(ios.width() == 0);
10572                                }
10573                                ios.width(25);
10574                                left(ios);
10575                                {
10576                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10577                                    std::string ex(str, iter.base());
10578                                    assert(ex == "-INF*********************");
10579                                    assert(ios.width() == 0);
10580                                }
10581                                ios.width(25);
10582                                right(ios);
10583                                {
10584                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10585                                    std::string ex(str, iter.base());
10586                                    assert(ex == "*********************-INF");
10587                                    assert(ios.width() == 0);
10588                                }
10589                                ios.width(25);
10590                                internal(ios);
10591                                {
10592                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10593                                    std::string ex(str, iter.base());
10594                                    assert(ex == "-*********************INF");
10595                                    assert(ios.width() == 0);
10596                                }
10597                            }
10598                            ios.imbue(lg);
10599                            {
10600                                ios.width(0);
10601                                {
10602                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10603                                    std::string ex(str, iter.base());
10604                                    assert(ex == "-INF");
10605                                    assert(ios.width() == 0);
10606                                }
10607                                ios.width(25);
10608                                left(ios);
10609                                {
10610                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10611                                    std::string ex(str, iter.base());
10612                                    assert(ex == "-INF*********************");
10613                                    assert(ios.width() == 0);
10614                                }
10615                                ios.width(25);
10616                                right(ios);
10617                                {
10618                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10619                                    std::string ex(str, iter.base());
10620                                    assert(ex == "*********************-INF");
10621                                    assert(ios.width() == 0);
10622                                }
10623                                ios.width(25);
10624                                internal(ios);
10625                                {
10626                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10627                                    std::string ex(str, iter.base());
10628                                    assert(ex == "-*********************INF");
10629                                    assert(ios.width() == 0);
10630                                }
10631                            }
10632                        }
10633                        showpoint(ios);
10634                        {
10635                            ios.imbue(lc);
10636                            {
10637                                ios.width(0);
10638                                {
10639                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10640                                    std::string ex(str, iter.base());
10641                                    assert(ex == "-INF");
10642                                    assert(ios.width() == 0);
10643                                }
10644                                ios.width(25);
10645                                left(ios);
10646                                {
10647                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10648                                    std::string ex(str, iter.base());
10649                                    assert(ex == "-INF*********************");
10650                                    assert(ios.width() == 0);
10651                                }
10652                                ios.width(25);
10653                                right(ios);
10654                                {
10655                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10656                                    std::string ex(str, iter.base());
10657                                    assert(ex == "*********************-INF");
10658                                    assert(ios.width() == 0);
10659                                }
10660                                ios.width(25);
10661                                internal(ios);
10662                                {
10663                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10664                                    std::string ex(str, iter.base());
10665                                    assert(ex == "-*********************INF");
10666                                    assert(ios.width() == 0);
10667                                }
10668                            }
10669                            ios.imbue(lg);
10670                            {
10671                                ios.width(0);
10672                                {
10673                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10674                                    std::string ex(str, iter.base());
10675                                    assert(ex == "-INF");
10676                                    assert(ios.width() == 0);
10677                                }
10678                                ios.width(25);
10679                                left(ios);
10680                                {
10681                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10682                                    std::string ex(str, iter.base());
10683                                    assert(ex == "-INF*********************");
10684                                    assert(ios.width() == 0);
10685                                }
10686                                ios.width(25);
10687                                right(ios);
10688                                {
10689                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10690                                    std::string ex(str, iter.base());
10691                                    assert(ex == "*********************-INF");
10692                                    assert(ios.width() == 0);
10693                                }
10694                                ios.width(25);
10695                                internal(ios);
10696                                {
10697                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10698                                    std::string ex(str, iter.base());
10699                                    assert(ex == "-*********************INF");
10700                                    assert(ios.width() == 0);
10701                                }
10702                            }
10703                        }
10704                    }
10705                }
10706            }
10707            ios.precision(16);
10708            {}
10709            ios.precision(60);
10710            {}
10711        }
10712    }
10713}
10714
10715void test5()
10716{
10717    char str[200];
10718    output_iterator<char*> iter;
10719    std::locale lc = std::locale::classic();
10720    std::locale lg(lc, new my_numpunct);
10721    const my_facet f(1);
10722    {
10723        long double v = std::nan("");
10724        std::ios ios(0);
10725        // %g
10726        {
10727            ios.precision(0);
10728            {
10729                nouppercase(ios);
10730                {
10731                    noshowpos(ios);
10732                    {
10733                        noshowpoint(ios);
10734                        {
10735                            ios.imbue(lc);
10736                            {
10737                                ios.width(0);
10738                                {
10739                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10740                                    std::string ex(str, iter.base());
10741                                    assert(ex == "nan");
10742                                    assert(ios.width() == 0);
10743                                }
10744                                ios.width(25);
10745                                left(ios);
10746                                {
10747                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10748                                    std::string ex(str, iter.base());
10749                                    assert(ex == "nan**********************");
10750                                    assert(ios.width() == 0);
10751                                }
10752                                ios.width(25);
10753                                right(ios);
10754                                {
10755                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10756                                    std::string ex(str, iter.base());
10757                                    assert(ex == "**********************nan");
10758                                    assert(ios.width() == 0);
10759                                }
10760                                ios.width(25);
10761                                internal(ios);
10762                                {
10763                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10764                                    std::string ex(str, iter.base());
10765                                    assert(ex == "**********************nan");
10766                                    assert(ios.width() == 0);
10767                                }
10768                            }
10769                            ios.imbue(lg);
10770                            {
10771                                ios.width(0);
10772                                {
10773                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10774                                    std::string ex(str, iter.base());
10775                                    assert(ex == "nan");
10776                                    assert(ios.width() == 0);
10777                                }
10778                                ios.width(25);
10779                                left(ios);
10780                                {
10781                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10782                                    std::string ex(str, iter.base());
10783                                    assert(ex == "nan**********************");
10784                                    assert(ios.width() == 0);
10785                                }
10786                                ios.width(25);
10787                                right(ios);
10788                                {
10789                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10790                                    std::string ex(str, iter.base());
10791                                    assert(ex == "**********************nan");
10792                                    assert(ios.width() == 0);
10793                                }
10794                                ios.width(25);
10795                                internal(ios);
10796                                {
10797                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10798                                    std::string ex(str, iter.base());
10799                                    assert(ex == "**********************nan");
10800                                    assert(ios.width() == 0);
10801                                }
10802                            }
10803                        }
10804                        showpoint(ios);
10805                        {
10806                            ios.imbue(lc);
10807                            {
10808                                ios.width(0);
10809                                {
10810                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10811                                    std::string ex(str, iter.base());
10812                                    assert(ex == "nan");
10813                                    assert(ios.width() == 0);
10814                                }
10815                                ios.width(25);
10816                                left(ios);
10817                                {
10818                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10819                                    std::string ex(str, iter.base());
10820                                    assert(ex == "nan**********************");
10821                                    assert(ios.width() == 0);
10822                                }
10823                                ios.width(25);
10824                                right(ios);
10825                                {
10826                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10827                                    std::string ex(str, iter.base());
10828                                    assert(ex == "**********************nan");
10829                                    assert(ios.width() == 0);
10830                                }
10831                                ios.width(25);
10832                                internal(ios);
10833                                {
10834                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10835                                    std::string ex(str, iter.base());
10836                                    assert(ex == "**********************nan");
10837                                    assert(ios.width() == 0);
10838                                }
10839                            }
10840                            ios.imbue(lg);
10841                            {
10842                                ios.width(0);
10843                                {
10844                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10845                                    std::string ex(str, iter.base());
10846                                    assert(ex == "nan");
10847                                    assert(ios.width() == 0);
10848                                }
10849                                ios.width(25);
10850                                left(ios);
10851                                {
10852                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10853                                    std::string ex(str, iter.base());
10854                                    assert(ex == "nan**********************");
10855                                    assert(ios.width() == 0);
10856                                }
10857                                ios.width(25);
10858                                right(ios);
10859                                {
10860                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10861                                    std::string ex(str, iter.base());
10862                                    assert(ex == "**********************nan");
10863                                    assert(ios.width() == 0);
10864                                }
10865                                ios.width(25);
10866                                internal(ios);
10867                                {
10868                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10869                                    std::string ex(str, iter.base());
10870                                    assert(ex == "**********************nan");
10871                                    assert(ios.width() == 0);
10872                                }
10873                            }
10874                        }
10875                    }
10876                    showpos(ios);
10877                    {
10878                        noshowpoint(ios);
10879                        {
10880                            ios.imbue(lc);
10881                            {
10882                                ios.width(0);
10883                                {
10884                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10885                                    std::string ex(str, iter.base());
10886                                    assert(ex == "nan");
10887                                    assert(ios.width() == 0);
10888                                }
10889                                ios.width(25);
10890                                left(ios);
10891                                {
10892                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10893                                    std::string ex(str, iter.base());
10894                                    assert(ex == "nan**********************");
10895                                    assert(ios.width() == 0);
10896                                }
10897                                ios.width(25);
10898                                right(ios);
10899                                {
10900                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10901                                    std::string ex(str, iter.base());
10902                                    assert(ex == "**********************nan");
10903                                    assert(ios.width() == 0);
10904                                }
10905                                ios.width(25);
10906                                internal(ios);
10907                                {
10908                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10909                                    std::string ex(str, iter.base());
10910                                    assert(ex == "**********************nan");
10911                                    assert(ios.width() == 0);
10912                                }
10913                            }
10914                            ios.imbue(lg);
10915                            {
10916                                ios.width(0);
10917                                {
10918                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10919                                    std::string ex(str, iter.base());
10920                                    assert(ex == "nan");
10921                                    assert(ios.width() == 0);
10922                                }
10923                                ios.width(25);
10924                                left(ios);
10925                                {
10926                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10927                                    std::string ex(str, iter.base());
10928                                    assert(ex == "nan**********************");
10929                                    assert(ios.width() == 0);
10930                                }
10931                                ios.width(25);
10932                                right(ios);
10933                                {
10934                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10935                                    std::string ex(str, iter.base());
10936                                    assert(ex == "**********************nan");
10937                                    assert(ios.width() == 0);
10938                                }
10939                                ios.width(25);
10940                                internal(ios);
10941                                {
10942                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10943                                    std::string ex(str, iter.base());
10944                                    assert(ex == "**********************nan");
10945                                    assert(ios.width() == 0);
10946                                }
10947                            }
10948                        }
10949                        showpoint(ios);
10950                        {
10951                            ios.imbue(lc);
10952                            {
10953                                ios.width(0);
10954                                {
10955                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10956                                    std::string ex(str, iter.base());
10957                                    assert(ex == "nan");
10958                                    assert(ios.width() == 0);
10959                                }
10960                                ios.width(25);
10961                                left(ios);
10962                                {
10963                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10964                                    std::string ex(str, iter.base());
10965                                    assert(ex == "nan**********************");
10966                                    assert(ios.width() == 0);
10967                                }
10968                                ios.width(25);
10969                                right(ios);
10970                                {
10971                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10972                                    std::string ex(str, iter.base());
10973                                    assert(ex == "**********************nan");
10974                                    assert(ios.width() == 0);
10975                                }
10976                                ios.width(25);
10977                                internal(ios);
10978                                {
10979                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10980                                    std::string ex(str, iter.base());
10981                                    assert(ex == "**********************nan");
10982                                    assert(ios.width() == 0);
10983                                }
10984                            }
10985                            ios.imbue(lg);
10986                            {
10987                                ios.width(0);
10988                                {
10989                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10990                                    std::string ex(str, iter.base());
10991                                    assert(ex == "nan");
10992                                    assert(ios.width() == 0);
10993                                }
10994                                ios.width(25);
10995                                left(ios);
10996                                {
10997                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
10998                                    std::string ex(str, iter.base());
10999                                    assert(ex == "nan**********************");
11000                                    assert(ios.width() == 0);
11001                                }
11002                                ios.width(25);
11003                                right(ios);
11004                                {
11005                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11006                                    std::string ex(str, iter.base());
11007                                    assert(ex == "**********************nan");
11008                                    assert(ios.width() == 0);
11009                                }
11010                                ios.width(25);
11011                                internal(ios);
11012                                {
11013                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11014                                    std::string ex(str, iter.base());
11015                                    assert(ex == "**********************nan");
11016                                    assert(ios.width() == 0);
11017                                }
11018                            }
11019                        }
11020                    }
11021                }
11022                uppercase(ios);
11023                {
11024                    noshowpos(ios);
11025                    {
11026                        noshowpoint(ios);
11027                        {
11028                            ios.imbue(lc);
11029                            {
11030                                ios.width(0);
11031                                {
11032                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11033                                    std::string ex(str, iter.base());
11034                                    assert(ex == "NAN");
11035                                    assert(ios.width() == 0);
11036                                }
11037                                ios.width(25);
11038                                left(ios);
11039                                {
11040                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11041                                    std::string ex(str, iter.base());
11042                                    assert(ex == "NAN**********************");
11043                                    assert(ios.width() == 0);
11044                                }
11045                                ios.width(25);
11046                                right(ios);
11047                                {
11048                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11049                                    std::string ex(str, iter.base());
11050                                    assert(ex == "**********************NAN");
11051                                    assert(ios.width() == 0);
11052                                }
11053                                ios.width(25);
11054                                internal(ios);
11055                                {
11056                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11057                                    std::string ex(str, iter.base());
11058                                    assert(ex == "**********************NAN");
11059                                    assert(ios.width() == 0);
11060                                }
11061                            }
11062                            ios.imbue(lg);
11063                            {
11064                                ios.width(0);
11065                                {
11066                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11067                                    std::string ex(str, iter.base());
11068                                    assert(ex == "NAN");
11069                                    assert(ios.width() == 0);
11070                                }
11071                                ios.width(25);
11072                                left(ios);
11073                                {
11074                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11075                                    std::string ex(str, iter.base());
11076                                    assert(ex == "NAN**********************");
11077                                    assert(ios.width() == 0);
11078                                }
11079                                ios.width(25);
11080                                right(ios);
11081                                {
11082                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11083                                    std::string ex(str, iter.base());
11084                                    assert(ex == "**********************NAN");
11085                                    assert(ios.width() == 0);
11086                                }
11087                                ios.width(25);
11088                                internal(ios);
11089                                {
11090                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11091                                    std::string ex(str, iter.base());
11092                                    assert(ex == "**********************NAN");
11093                                    assert(ios.width() == 0);
11094                                }
11095                            }
11096                        }
11097                        showpoint(ios);
11098                        {
11099                            ios.imbue(lc);
11100                            {
11101                                ios.width(0);
11102                                {
11103                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11104                                    std::string ex(str, iter.base());
11105                                    assert(ex == "NAN");
11106                                    assert(ios.width() == 0);
11107                                }
11108                                ios.width(25);
11109                                left(ios);
11110                                {
11111                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11112                                    std::string ex(str, iter.base());
11113                                    assert(ex == "NAN**********************");
11114                                    assert(ios.width() == 0);
11115                                }
11116                                ios.width(25);
11117                                right(ios);
11118                                {
11119                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11120                                    std::string ex(str, iter.base());
11121                                    assert(ex == "**********************NAN");
11122                                    assert(ios.width() == 0);
11123                                }
11124                                ios.width(25);
11125                                internal(ios);
11126                                {
11127                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11128                                    std::string ex(str, iter.base());
11129                                    assert(ex == "**********************NAN");
11130                                    assert(ios.width() == 0);
11131                                }
11132                            }
11133                            ios.imbue(lg);
11134                            {
11135                                ios.width(0);
11136                                {
11137                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11138                                    std::string ex(str, iter.base());
11139                                    assert(ex == "NAN");
11140                                    assert(ios.width() == 0);
11141                                }
11142                                ios.width(25);
11143                                left(ios);
11144                                {
11145                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11146                                    std::string ex(str, iter.base());
11147                                    assert(ex == "NAN**********************");
11148                                    assert(ios.width() == 0);
11149                                }
11150                                ios.width(25);
11151                                right(ios);
11152                                {
11153                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11154                                    std::string ex(str, iter.base());
11155                                    assert(ex == "**********************NAN");
11156                                    assert(ios.width() == 0);
11157                                }
11158                                ios.width(25);
11159                                internal(ios);
11160                                {
11161                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11162                                    std::string ex(str, iter.base());
11163                                    assert(ex == "**********************NAN");
11164                                    assert(ios.width() == 0);
11165                                }
11166                            }
11167                        }
11168                    }
11169                    showpos(ios);
11170                    {
11171                        noshowpoint(ios);
11172                        {
11173                            ios.imbue(lc);
11174                            {
11175                                ios.width(0);
11176                                {
11177                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11178                                    std::string ex(str, iter.base());
11179                                    assert(ex == "NAN");
11180                                    assert(ios.width() == 0);
11181                                }
11182                                ios.width(25);
11183                                left(ios);
11184                                {
11185                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11186                                    std::string ex(str, iter.base());
11187                                    assert(ex == "NAN**********************");
11188                                    assert(ios.width() == 0);
11189                                }
11190                                ios.width(25);
11191                                right(ios);
11192                                {
11193                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11194                                    std::string ex(str, iter.base());
11195                                    assert(ex == "**********************NAN");
11196                                    assert(ios.width() == 0);
11197                                }
11198                                ios.width(25);
11199                                internal(ios);
11200                                {
11201                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11202                                    std::string ex(str, iter.base());
11203                                    assert(ex == "**********************NAN");
11204                                    assert(ios.width() == 0);
11205                                }
11206                            }
11207                            ios.imbue(lg);
11208                            {
11209                                ios.width(0);
11210                                {
11211                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11212                                    std::string ex(str, iter.base());
11213                                    assert(ex == "NAN");
11214                                    assert(ios.width() == 0);
11215                                }
11216                                ios.width(25);
11217                                left(ios);
11218                                {
11219                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11220                                    std::string ex(str, iter.base());
11221                                    assert(ex == "NAN**********************");
11222                                    assert(ios.width() == 0);
11223                                }
11224                                ios.width(25);
11225                                right(ios);
11226                                {
11227                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11228                                    std::string ex(str, iter.base());
11229                                    assert(ex == "**********************NAN");
11230                                    assert(ios.width() == 0);
11231                                }
11232                                ios.width(25);
11233                                internal(ios);
11234                                {
11235                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11236                                    std::string ex(str, iter.base());
11237                                    assert(ex == "**********************NAN");
11238                                    assert(ios.width() == 0);
11239                                }
11240                            }
11241                        }
11242                        showpoint(ios);
11243                        {
11244                            ios.imbue(lc);
11245                            {
11246                                ios.width(0);
11247                                {
11248                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11249                                    std::string ex(str, iter.base());
11250                                    assert(ex == "NAN");
11251                                    assert(ios.width() == 0);
11252                                }
11253                                ios.width(25);
11254                                left(ios);
11255                                {
11256                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11257                                    std::string ex(str, iter.base());
11258                                    assert(ex == "NAN**********************");
11259                                    assert(ios.width() == 0);
11260                                }
11261                                ios.width(25);
11262                                right(ios);
11263                                {
11264                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11265                                    std::string ex(str, iter.base());
11266                                    assert(ex == "**********************NAN");
11267                                    assert(ios.width() == 0);
11268                                }
11269                                ios.width(25);
11270                                internal(ios);
11271                                {
11272                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11273                                    std::string ex(str, iter.base());
11274                                    assert(ex == "**********************NAN");
11275                                    assert(ios.width() == 0);
11276                                }
11277                            }
11278                            ios.imbue(lg);
11279                            {
11280                                ios.width(0);
11281                                {
11282                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11283                                    std::string ex(str, iter.base());
11284                                    assert(ex == "NAN");
11285                                    assert(ios.width() == 0);
11286                                }
11287                                ios.width(25);
11288                                left(ios);
11289                                {
11290                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11291                                    std::string ex(str, iter.base());
11292                                    assert(ex == "NAN**********************");
11293                                    assert(ios.width() == 0);
11294                                }
11295                                ios.width(25);
11296                                right(ios);
11297                                {
11298                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11299                                    std::string ex(str, iter.base());
11300                                    assert(ex == "**********************NAN");
11301                                    assert(ios.width() == 0);
11302                                }
11303                                ios.width(25);
11304                                internal(ios);
11305                                {
11306                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11307                                    std::string ex(str, iter.base());
11308                                    assert(ex == "**********************NAN");
11309                                    assert(ios.width() == 0);
11310                                }
11311                            }
11312                        }
11313                    }
11314                }
11315            }
11316            ios.precision(1);
11317            {}
11318            ios.precision(6);
11319            {}
11320            ios.precision(16);
11321            {}
11322            ios.precision(60);
11323            {}
11324        }
11325    }
11326}
11327
11328void test6()
11329{
11330    char str[200];
11331    output_iterator<char*> iter;
11332    std::locale lc = std::locale::classic();
11333    std::locale lg(lc, new my_numpunct);
11334    const my_facet f(1);
11335    {
11336        long double v = +0.;
11337        std::ios ios(0);
11338        fixed(ios);
11339        // %f
11340        {
11341            ios.precision(0);
11342            {
11343                nouppercase(ios);
11344                {
11345                    noshowpos(ios);
11346                    {
11347                        noshowpoint(ios);
11348                        {
11349                            ios.imbue(lc);
11350                            {
11351                                ios.width(0);
11352                                {
11353                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11354                                    std::string ex(str, iter.base());
11355                                    assert(ex == "0");
11356                                    assert(ios.width() == 0);
11357                                }
11358                                ios.width(25);
11359                                left(ios);
11360                                {
11361                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11362                                    std::string ex(str, iter.base());
11363                                    assert(ex == "0************************");
11364                                    assert(ios.width() == 0);
11365                                }
11366                                ios.width(25);
11367                                right(ios);
11368                                {
11369                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11370                                    std::string ex(str, iter.base());
11371                                    assert(ex == "************************0");
11372                                    assert(ios.width() == 0);
11373                                }
11374                                ios.width(25);
11375                                internal(ios);
11376                                {
11377                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11378                                    std::string ex(str, iter.base());
11379                                    assert(ex == "************************0");
11380                                    assert(ios.width() == 0);
11381                                }
11382                            }
11383                            ios.imbue(lg);
11384                            {
11385                                ios.width(0);
11386                                {
11387                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11388                                    std::string ex(str, iter.base());
11389                                    assert(ex == "0");
11390                                    assert(ios.width() == 0);
11391                                }
11392                                ios.width(25);
11393                                left(ios);
11394                                {
11395                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11396                                    std::string ex(str, iter.base());
11397                                    assert(ex == "0************************");
11398                                    assert(ios.width() == 0);
11399                                }
11400                                ios.width(25);
11401                                right(ios);
11402                                {
11403                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11404                                    std::string ex(str, iter.base());
11405                                    assert(ex == "************************0");
11406                                    assert(ios.width() == 0);
11407                                }
11408                                ios.width(25);
11409                                internal(ios);
11410                                {
11411                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11412                                    std::string ex(str, iter.base());
11413                                    assert(ex == "************************0");
11414                                    assert(ios.width() == 0);
11415                                }
11416                            }
11417                        }
11418                        showpoint(ios);
11419                        {
11420                            ios.imbue(lc);
11421                            {
11422                                ios.width(0);
11423                                {
11424                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11425                                    std::string ex(str, iter.base());
11426                                    assert(ex == "0.");
11427                                    assert(ios.width() == 0);
11428                                }
11429                                ios.width(25);
11430                                left(ios);
11431                                {
11432                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11433                                    std::string ex(str, iter.base());
11434                                    assert(ex == "0.***********************");
11435                                    assert(ios.width() == 0);
11436                                }
11437                                ios.width(25);
11438                                right(ios);
11439                                {
11440                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11441                                    std::string ex(str, iter.base());
11442                                    assert(ex == "***********************0.");
11443                                    assert(ios.width() == 0);
11444                                }
11445                                ios.width(25);
11446                                internal(ios);
11447                                {
11448                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11449                                    std::string ex(str, iter.base());
11450                                    assert(ex == "***********************0.");
11451                                    assert(ios.width() == 0);
11452                                }
11453                            }
11454                            ios.imbue(lg);
11455                            {
11456                                ios.width(0);
11457                                {
11458                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11459                                    std::string ex(str, iter.base());
11460                                    assert(ex == "0;");
11461                                    assert(ios.width() == 0);
11462                                }
11463                                ios.width(25);
11464                                left(ios);
11465                                {
11466                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11467                                    std::string ex(str, iter.base());
11468                                    assert(ex == "0;***********************");
11469                                    assert(ios.width() == 0);
11470                                }
11471                                ios.width(25);
11472                                right(ios);
11473                                {
11474                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11475                                    std::string ex(str, iter.base());
11476                                    assert(ex == "***********************0;");
11477                                    assert(ios.width() == 0);
11478                                }
11479                                ios.width(25);
11480                                internal(ios);
11481                                {
11482                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11483                                    std::string ex(str, iter.base());
11484                                    assert(ex == "***********************0;");
11485                                    assert(ios.width() == 0);
11486                                }
11487                            }
11488                        }
11489                    }
11490                    showpos(ios);
11491                    {
11492                        noshowpoint(ios);
11493                        {
11494                            ios.imbue(lc);
11495                            {
11496                                ios.width(0);
11497                                {
11498                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11499                                    std::string ex(str, iter.base());
11500                                    assert(ex == "+0");
11501                                    assert(ios.width() == 0);
11502                                }
11503                                ios.width(25);
11504                                left(ios);
11505                                {
11506                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11507                                    std::string ex(str, iter.base());
11508                                    assert(ex == "+0***********************");
11509                                    assert(ios.width() == 0);
11510                                }
11511                                ios.width(25);
11512                                right(ios);
11513                                {
11514                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11515                                    std::string ex(str, iter.base());
11516                                    assert(ex == "***********************+0");
11517                                    assert(ios.width() == 0);
11518                                }
11519                                ios.width(25);
11520                                internal(ios);
11521                                {
11522                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11523                                    std::string ex(str, iter.base());
11524                                    assert(ex == "+***********************0");
11525                                    assert(ios.width() == 0);
11526                                }
11527                            }
11528                            ios.imbue(lg);
11529                            {
11530                                ios.width(0);
11531                                {
11532                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11533                                    std::string ex(str, iter.base());
11534                                    assert(ex == "+0");
11535                                    assert(ios.width() == 0);
11536                                }
11537                                ios.width(25);
11538                                left(ios);
11539                                {
11540                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11541                                    std::string ex(str, iter.base());
11542                                    assert(ex == "+0***********************");
11543                                    assert(ios.width() == 0);
11544                                }
11545                                ios.width(25);
11546                                right(ios);
11547                                {
11548                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11549                                    std::string ex(str, iter.base());
11550                                    assert(ex == "***********************+0");
11551                                    assert(ios.width() == 0);
11552                                }
11553                                ios.width(25);
11554                                internal(ios);
11555                                {
11556                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11557                                    std::string ex(str, iter.base());
11558                                    assert(ex == "+***********************0");
11559                                    assert(ios.width() == 0);
11560                                }
11561                            }
11562                        }
11563                        showpoint(ios);
11564                        {
11565                            ios.imbue(lc);
11566                            {
11567                                ios.width(0);
11568                                {
11569                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11570                                    std::string ex(str, iter.base());
11571                                    assert(ex == "+0.");
11572                                    assert(ios.width() == 0);
11573                                }
11574                                ios.width(25);
11575                                left(ios);
11576                                {
11577                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11578                                    std::string ex(str, iter.base());
11579                                    assert(ex == "+0.**********************");
11580                                    assert(ios.width() == 0);
11581                                }
11582                                ios.width(25);
11583                                right(ios);
11584                                {
11585                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11586                                    std::string ex(str, iter.base());
11587                                    assert(ex == "**********************+0.");
11588                                    assert(ios.width() == 0);
11589                                }
11590                                ios.width(25);
11591                                internal(ios);
11592                                {
11593                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11594                                    std::string ex(str, iter.base());
11595                                    assert(ex == "+**********************0.");
11596                                    assert(ios.width() == 0);
11597                                }
11598                            }
11599                            ios.imbue(lg);
11600                            {
11601                                ios.width(0);
11602                                {
11603                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11604                                    std::string ex(str, iter.base());
11605                                    assert(ex == "+0;");
11606                                    assert(ios.width() == 0);
11607                                }
11608                                ios.width(25);
11609                                left(ios);
11610                                {
11611                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11612                                    std::string ex(str, iter.base());
11613                                    assert(ex == "+0;**********************");
11614                                    assert(ios.width() == 0);
11615                                }
11616                                ios.width(25);
11617                                right(ios);
11618                                {
11619                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11620                                    std::string ex(str, iter.base());
11621                                    assert(ex == "**********************+0;");
11622                                    assert(ios.width() == 0);
11623                                }
11624                                ios.width(25);
11625                                internal(ios);
11626                                {
11627                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11628                                    std::string ex(str, iter.base());
11629                                    assert(ex == "+**********************0;");
11630                                    assert(ios.width() == 0);
11631                                }
11632                            }
11633                        }
11634                    }
11635                }
11636                uppercase(ios);
11637                {
11638                    noshowpos(ios);
11639                    {
11640                        noshowpoint(ios);
11641                        {
11642                            ios.imbue(lc);
11643                            {
11644                                ios.width(0);
11645                                {
11646                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11647                                    std::string ex(str, iter.base());
11648                                    assert(ex == "0");
11649                                    assert(ios.width() == 0);
11650                                }
11651                                ios.width(25);
11652                                left(ios);
11653                                {
11654                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11655                                    std::string ex(str, iter.base());
11656                                    assert(ex == "0************************");
11657                                    assert(ios.width() == 0);
11658                                }
11659                                ios.width(25);
11660                                right(ios);
11661                                {
11662                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11663                                    std::string ex(str, iter.base());
11664                                    assert(ex == "************************0");
11665                                    assert(ios.width() == 0);
11666                                }
11667                                ios.width(25);
11668                                internal(ios);
11669                                {
11670                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11671                                    std::string ex(str, iter.base());
11672                                    assert(ex == "************************0");
11673                                    assert(ios.width() == 0);
11674                                }
11675                            }
11676                            ios.imbue(lg);
11677                            {
11678                                ios.width(0);
11679                                {
11680                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11681                                    std::string ex(str, iter.base());
11682                                    assert(ex == "0");
11683                                    assert(ios.width() == 0);
11684                                }
11685                                ios.width(25);
11686                                left(ios);
11687                                {
11688                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11689                                    std::string ex(str, iter.base());
11690                                    assert(ex == "0************************");
11691                                    assert(ios.width() == 0);
11692                                }
11693                                ios.width(25);
11694                                right(ios);
11695                                {
11696                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11697                                    std::string ex(str, iter.base());
11698                                    assert(ex == "************************0");
11699                                    assert(ios.width() == 0);
11700                                }
11701                                ios.width(25);
11702                                internal(ios);
11703                                {
11704                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11705                                    std::string ex(str, iter.base());
11706                                    assert(ex == "************************0");
11707                                    assert(ios.width() == 0);
11708                                }
11709                            }
11710                        }
11711                        showpoint(ios);
11712                        {
11713                            ios.imbue(lc);
11714                            {
11715                                ios.width(0);
11716                                {
11717                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11718                                    std::string ex(str, iter.base());
11719                                    assert(ex == "0.");
11720                                    assert(ios.width() == 0);
11721                                }
11722                                ios.width(25);
11723                                left(ios);
11724                                {
11725                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11726                                    std::string ex(str, iter.base());
11727                                    assert(ex == "0.***********************");
11728                                    assert(ios.width() == 0);
11729                                }
11730                                ios.width(25);
11731                                right(ios);
11732                                {
11733                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11734                                    std::string ex(str, iter.base());
11735                                    assert(ex == "***********************0.");
11736                                    assert(ios.width() == 0);
11737                                }
11738                                ios.width(25);
11739                                internal(ios);
11740                                {
11741                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11742                                    std::string ex(str, iter.base());
11743                                    assert(ex == "***********************0.");
11744                                    assert(ios.width() == 0);
11745                                }
11746                            }
11747                            ios.imbue(lg);
11748                            {
11749                                ios.width(0);
11750                                {
11751                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11752                                    std::string ex(str, iter.base());
11753                                    assert(ex == "0;");
11754                                    assert(ios.width() == 0);
11755                                }
11756                                ios.width(25);
11757                                left(ios);
11758                                {
11759                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11760                                    std::string ex(str, iter.base());
11761                                    assert(ex == "0;***********************");
11762                                    assert(ios.width() == 0);
11763                                }
11764                                ios.width(25);
11765                                right(ios);
11766                                {
11767                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11768                                    std::string ex(str, iter.base());
11769                                    assert(ex == "***********************0;");
11770                                    assert(ios.width() == 0);
11771                                }
11772                                ios.width(25);
11773                                internal(ios);
11774                                {
11775                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11776                                    std::string ex(str, iter.base());
11777                                    assert(ex == "***********************0;");
11778                                    assert(ios.width() == 0);
11779                                }
11780                            }
11781                        }
11782                    }
11783                    showpos(ios);
11784                    {
11785                        noshowpoint(ios);
11786                        {
11787                            ios.imbue(lc);
11788                            {
11789                                ios.width(0);
11790                                {
11791                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11792                                    std::string ex(str, iter.base());
11793                                    assert(ex == "+0");
11794                                    assert(ios.width() == 0);
11795                                }
11796                                ios.width(25);
11797                                left(ios);
11798                                {
11799                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11800                                    std::string ex(str, iter.base());
11801                                    assert(ex == "+0***********************");
11802                                    assert(ios.width() == 0);
11803                                }
11804                                ios.width(25);
11805                                right(ios);
11806                                {
11807                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11808                                    std::string ex(str, iter.base());
11809                                    assert(ex == "***********************+0");
11810                                    assert(ios.width() == 0);
11811                                }
11812                                ios.width(25);
11813                                internal(ios);
11814                                {
11815                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11816                                    std::string ex(str, iter.base());
11817                                    assert(ex == "+***********************0");
11818                                    assert(ios.width() == 0);
11819                                }
11820                            }
11821                            ios.imbue(lg);
11822                            {
11823                                ios.width(0);
11824                                {
11825                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11826                                    std::string ex(str, iter.base());
11827                                    assert(ex == "+0");
11828                                    assert(ios.width() == 0);
11829                                }
11830                                ios.width(25);
11831                                left(ios);
11832                                {
11833                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11834                                    std::string ex(str, iter.base());
11835                                    assert(ex == "+0***********************");
11836                                    assert(ios.width() == 0);
11837                                }
11838                                ios.width(25);
11839                                right(ios);
11840                                {
11841                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11842                                    std::string ex(str, iter.base());
11843                                    assert(ex == "***********************+0");
11844                                    assert(ios.width() == 0);
11845                                }
11846                                ios.width(25);
11847                                internal(ios);
11848                                {
11849                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11850                                    std::string ex(str, iter.base());
11851                                    assert(ex == "+***********************0");
11852                                    assert(ios.width() == 0);
11853                                }
11854                            }
11855                        }
11856                        showpoint(ios);
11857                        {
11858                            ios.imbue(lc);
11859                            {
11860                                ios.width(0);
11861                                {
11862                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11863                                    std::string ex(str, iter.base());
11864                                    assert(ex == "+0.");
11865                                    assert(ios.width() == 0);
11866                                }
11867                                ios.width(25);
11868                                left(ios);
11869                                {
11870                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11871                                    std::string ex(str, iter.base());
11872                                    assert(ex == "+0.**********************");
11873                                    assert(ios.width() == 0);
11874                                }
11875                                ios.width(25);
11876                                right(ios);
11877                                {
11878                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11879                                    std::string ex(str, iter.base());
11880                                    assert(ex == "**********************+0.");
11881                                    assert(ios.width() == 0);
11882                                }
11883                                ios.width(25);
11884                                internal(ios);
11885                                {
11886                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11887                                    std::string ex(str, iter.base());
11888                                    assert(ex == "+**********************0.");
11889                                    assert(ios.width() == 0);
11890                                }
11891                            }
11892                            ios.imbue(lg);
11893                            {
11894                                ios.width(0);
11895                                {
11896                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11897                                    std::string ex(str, iter.base());
11898                                    assert(ex == "+0;");
11899                                    assert(ios.width() == 0);
11900                                }
11901                                ios.width(25);
11902                                left(ios);
11903                                {
11904                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11905                                    std::string ex(str, iter.base());
11906                                    assert(ex == "+0;**********************");
11907                                    assert(ios.width() == 0);
11908                                }
11909                                ios.width(25);
11910                                right(ios);
11911                                {
11912                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11913                                    std::string ex(str, iter.base());
11914                                    assert(ex == "**********************+0;");
11915                                    assert(ios.width() == 0);
11916                                }
11917                                ios.width(25);
11918                                internal(ios);
11919                                {
11920                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11921                                    std::string ex(str, iter.base());
11922                                    assert(ex == "+**********************0;");
11923                                    assert(ios.width() == 0);
11924                                }
11925                            }
11926                        }
11927                    }
11928                }
11929            }
11930            ios.precision(1);
11931            {
11932                nouppercase(ios);
11933                {
11934                    noshowpos(ios);
11935                    {
11936                        noshowpoint(ios);
11937                        {
11938                            ios.imbue(lc);
11939                            {
11940                                ios.width(0);
11941                                {
11942                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11943                                    std::string ex(str, iter.base());
11944                                    assert(ex == "0.0");
11945                                    assert(ios.width() == 0);
11946                                }
11947                                ios.width(25);
11948                                left(ios);
11949                                {
11950                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11951                                    std::string ex(str, iter.base());
11952                                    assert(ex == "0.0**********************");
11953                                    assert(ios.width() == 0);
11954                                }
11955                                ios.width(25);
11956                                right(ios);
11957                                {
11958                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11959                                    std::string ex(str, iter.base());
11960                                    assert(ex == "**********************0.0");
11961                                    assert(ios.width() == 0);
11962                                }
11963                                ios.width(25);
11964                                internal(ios);
11965                                {
11966                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11967                                    std::string ex(str, iter.base());
11968                                    assert(ex == "**********************0.0");
11969                                    assert(ios.width() == 0);
11970                                }
11971                            }
11972                            ios.imbue(lg);
11973                            {
11974                                ios.width(0);
11975                                {
11976                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11977                                    std::string ex(str, iter.base());
11978                                    assert(ex == "0;0");
11979                                    assert(ios.width() == 0);
11980                                }
11981                                ios.width(25);
11982                                left(ios);
11983                                {
11984                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11985                                    std::string ex(str, iter.base());
11986                                    assert(ex == "0;0**********************");
11987                                    assert(ios.width() == 0);
11988                                }
11989                                ios.width(25);
11990                                right(ios);
11991                                {
11992                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
11993                                    std::string ex(str, iter.base());
11994                                    assert(ex == "**********************0;0");
11995                                    assert(ios.width() == 0);
11996                                }
11997                                ios.width(25);
11998                                internal(ios);
11999                                {
12000                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12001                                    std::string ex(str, iter.base());
12002                                    assert(ex == "**********************0;0");
12003                                    assert(ios.width() == 0);
12004                                }
12005                            }
12006                        }
12007                        showpoint(ios);
12008                        {
12009                            ios.imbue(lc);
12010                            {
12011                                ios.width(0);
12012                                {
12013                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12014                                    std::string ex(str, iter.base());
12015                                    assert(ex == "0.0");
12016                                    assert(ios.width() == 0);
12017                                }
12018                                ios.width(25);
12019                                left(ios);
12020                                {
12021                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12022                                    std::string ex(str, iter.base());
12023                                    assert(ex == "0.0**********************");
12024                                    assert(ios.width() == 0);
12025                                }
12026                                ios.width(25);
12027                                right(ios);
12028                                {
12029                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12030                                    std::string ex(str, iter.base());
12031                                    assert(ex == "**********************0.0");
12032                                    assert(ios.width() == 0);
12033                                }
12034                                ios.width(25);
12035                                internal(ios);
12036                                {
12037                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12038                                    std::string ex(str, iter.base());
12039                                    assert(ex == "**********************0.0");
12040                                    assert(ios.width() == 0);
12041                                }
12042                            }
12043                            ios.imbue(lg);
12044                            {
12045                                ios.width(0);
12046                                {
12047                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12048                                    std::string ex(str, iter.base());
12049                                    assert(ex == "0;0");
12050                                    assert(ios.width() == 0);
12051                                }
12052                                ios.width(25);
12053                                left(ios);
12054                                {
12055                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12056                                    std::string ex(str, iter.base());
12057                                    assert(ex == "0;0**********************");
12058                                    assert(ios.width() == 0);
12059                                }
12060                                ios.width(25);
12061                                right(ios);
12062                                {
12063                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12064                                    std::string ex(str, iter.base());
12065                                    assert(ex == "**********************0;0");
12066                                    assert(ios.width() == 0);
12067                                }
12068                                ios.width(25);
12069                                internal(ios);
12070                                {
12071                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12072                                    std::string ex(str, iter.base());
12073                                    assert(ex == "**********************0;0");
12074                                    assert(ios.width() == 0);
12075                                }
12076                            }
12077                        }
12078                    }
12079                    showpos(ios);
12080                    {
12081                        noshowpoint(ios);
12082                        {
12083                            ios.imbue(lc);
12084                            {
12085                                ios.width(0);
12086                                {
12087                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12088                                    std::string ex(str, iter.base());
12089                                    assert(ex == "+0.0");
12090                                    assert(ios.width() == 0);
12091                                }
12092                                ios.width(25);
12093                                left(ios);
12094                                {
12095                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12096                                    std::string ex(str, iter.base());
12097                                    assert(ex == "+0.0*********************");
12098                                    assert(ios.width() == 0);
12099                                }
12100                                ios.width(25);
12101                                right(ios);
12102                                {
12103                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12104                                    std::string ex(str, iter.base());
12105                                    assert(ex == "*********************+0.0");
12106                                    assert(ios.width() == 0);
12107                                }
12108                                ios.width(25);
12109                                internal(ios);
12110                                {
12111                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12112                                    std::string ex(str, iter.base());
12113                                    assert(ex == "+*********************0.0");
12114                                    assert(ios.width() == 0);
12115                                }
12116                            }
12117                            ios.imbue(lg);
12118                            {
12119                                ios.width(0);
12120                                {
12121                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12122                                    std::string ex(str, iter.base());
12123                                    assert(ex == "+0;0");
12124                                    assert(ios.width() == 0);
12125                                }
12126                                ios.width(25);
12127                                left(ios);
12128                                {
12129                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12130                                    std::string ex(str, iter.base());
12131                                    assert(ex == "+0;0*********************");
12132                                    assert(ios.width() == 0);
12133                                }
12134                                ios.width(25);
12135                                right(ios);
12136                                {
12137                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12138                                    std::string ex(str, iter.base());
12139                                    assert(ex == "*********************+0;0");
12140                                    assert(ios.width() == 0);
12141                                }
12142                                ios.width(25);
12143                                internal(ios);
12144                                {
12145                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12146                                    std::string ex(str, iter.base());
12147                                    assert(ex == "+*********************0;0");
12148                                    assert(ios.width() == 0);
12149                                }
12150                            }
12151                        }
12152                        showpoint(ios);
12153                        {
12154                            ios.imbue(lc);
12155                            {
12156                                ios.width(0);
12157                                {
12158                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12159                                    std::string ex(str, iter.base());
12160                                    assert(ex == "+0.0");
12161                                    assert(ios.width() == 0);
12162                                }
12163                                ios.width(25);
12164                                left(ios);
12165                                {
12166                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12167                                    std::string ex(str, iter.base());
12168                                    assert(ex == "+0.0*********************");
12169                                    assert(ios.width() == 0);
12170                                }
12171                                ios.width(25);
12172                                right(ios);
12173                                {
12174                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12175                                    std::string ex(str, iter.base());
12176                                    assert(ex == "*********************+0.0");
12177                                    assert(ios.width() == 0);
12178                                }
12179                                ios.width(25);
12180                                internal(ios);
12181                                {
12182                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12183                                    std::string ex(str, iter.base());
12184                                    assert(ex == "+*********************0.0");
12185                                    assert(ios.width() == 0);
12186                                }
12187                            }
12188                            ios.imbue(lg);
12189                            {
12190                                ios.width(0);
12191                                {
12192                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12193                                    std::string ex(str, iter.base());
12194                                    assert(ex == "+0;0");
12195                                    assert(ios.width() == 0);
12196                                }
12197                                ios.width(25);
12198                                left(ios);
12199                                {
12200                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12201                                    std::string ex(str, iter.base());
12202                                    assert(ex == "+0;0*********************");
12203                                    assert(ios.width() == 0);
12204                                }
12205                                ios.width(25);
12206                                right(ios);
12207                                {
12208                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12209                                    std::string ex(str, iter.base());
12210                                    assert(ex == "*********************+0;0");
12211                                    assert(ios.width() == 0);
12212                                }
12213                                ios.width(25);
12214                                internal(ios);
12215                                {
12216                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12217                                    std::string ex(str, iter.base());
12218                                    assert(ex == "+*********************0;0");
12219                                    assert(ios.width() == 0);
12220                                }
12221                            }
12222                        }
12223                    }
12224                }
12225                uppercase(ios);
12226                {
12227                    noshowpos(ios);
12228                    {
12229                        noshowpoint(ios);
12230                        {
12231                            ios.imbue(lc);
12232                            {
12233                                ios.width(0);
12234                                {
12235                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12236                                    std::string ex(str, iter.base());
12237                                    assert(ex == "0.0");
12238                                    assert(ios.width() == 0);
12239                                }
12240                                ios.width(25);
12241                                left(ios);
12242                                {
12243                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12244                                    std::string ex(str, iter.base());
12245                                    assert(ex == "0.0**********************");
12246                                    assert(ios.width() == 0);
12247                                }
12248                                ios.width(25);
12249                                right(ios);
12250                                {
12251                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12252                                    std::string ex(str, iter.base());
12253                                    assert(ex == "**********************0.0");
12254                                    assert(ios.width() == 0);
12255                                }
12256                                ios.width(25);
12257                                internal(ios);
12258                                {
12259                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12260                                    std::string ex(str, iter.base());
12261                                    assert(ex == "**********************0.0");
12262                                    assert(ios.width() == 0);
12263                                }
12264                            }
12265                            ios.imbue(lg);
12266                            {
12267                                ios.width(0);
12268                                {
12269                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12270                                    std::string ex(str, iter.base());
12271                                    assert(ex == "0;0");
12272                                    assert(ios.width() == 0);
12273                                }
12274                                ios.width(25);
12275                                left(ios);
12276                                {
12277                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12278                                    std::string ex(str, iter.base());
12279                                    assert(ex == "0;0**********************");
12280                                    assert(ios.width() == 0);
12281                                }
12282                                ios.width(25);
12283                                right(ios);
12284                                {
12285                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12286                                    std::string ex(str, iter.base());
12287                                    assert(ex == "**********************0;0");
12288                                    assert(ios.width() == 0);
12289                                }
12290                                ios.width(25);
12291                                internal(ios);
12292                                {
12293                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12294                                    std::string ex(str, iter.base());
12295                                    assert(ex == "**********************0;0");
12296                                    assert(ios.width() == 0);
12297                                }
12298                            }
12299                        }
12300                        showpoint(ios);
12301                        {
12302                            ios.imbue(lc);
12303                            {
12304                                ios.width(0);
12305                                {
12306                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12307                                    std::string ex(str, iter.base());
12308                                    assert(ex == "0.0");
12309                                    assert(ios.width() == 0);
12310                                }
12311                                ios.width(25);
12312                                left(ios);
12313                                {
12314                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12315                                    std::string ex(str, iter.base());
12316                                    assert(ex == "0.0**********************");
12317                                    assert(ios.width() == 0);
12318                                }
12319                                ios.width(25);
12320                                right(ios);
12321                                {
12322                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12323                                    std::string ex(str, iter.base());
12324                                    assert(ex == "**********************0.0");
12325                                    assert(ios.width() == 0);
12326                                }
12327                                ios.width(25);
12328                                internal(ios);
12329                                {
12330                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12331                                    std::string ex(str, iter.base());
12332                                    assert(ex == "**********************0.0");
12333                                    assert(ios.width() == 0);
12334                                }
12335                            }
12336                            ios.imbue(lg);
12337                            {
12338                                ios.width(0);
12339                                {
12340                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12341                                    std::string ex(str, iter.base());
12342                                    assert(ex == "0;0");
12343                                    assert(ios.width() == 0);
12344                                }
12345                                ios.width(25);
12346                                left(ios);
12347                                {
12348                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12349                                    std::string ex(str, iter.base());
12350                                    assert(ex == "0;0**********************");
12351                                    assert(ios.width() == 0);
12352                                }
12353                                ios.width(25);
12354                                right(ios);
12355                                {
12356                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12357                                    std::string ex(str, iter.base());
12358                                    assert(ex == "**********************0;0");
12359                                    assert(ios.width() == 0);
12360                                }
12361                                ios.width(25);
12362                                internal(ios);
12363                                {
12364                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12365                                    std::string ex(str, iter.base());
12366                                    assert(ex == "**********************0;0");
12367                                    assert(ios.width() == 0);
12368                                }
12369                            }
12370                        }
12371                    }
12372                    showpos(ios);
12373                    {
12374                        noshowpoint(ios);
12375                        {
12376                            ios.imbue(lc);
12377                            {
12378                                ios.width(0);
12379                                {
12380                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12381                                    std::string ex(str, iter.base());
12382                                    assert(ex == "+0.0");
12383                                    assert(ios.width() == 0);
12384                                }
12385                                ios.width(25);
12386                                left(ios);
12387                                {
12388                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12389                                    std::string ex(str, iter.base());
12390                                    assert(ex == "+0.0*********************");
12391                                    assert(ios.width() == 0);
12392                                }
12393                                ios.width(25);
12394                                right(ios);
12395                                {
12396                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12397                                    std::string ex(str, iter.base());
12398                                    assert(ex == "*********************+0.0");
12399                                    assert(ios.width() == 0);
12400                                }
12401                                ios.width(25);
12402                                internal(ios);
12403                                {
12404                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12405                                    std::string ex(str, iter.base());
12406                                    assert(ex == "+*********************0.0");
12407                                    assert(ios.width() == 0);
12408                                }
12409                            }
12410                            ios.imbue(lg);
12411                            {
12412                                ios.width(0);
12413                                {
12414                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12415                                    std::string ex(str, iter.base());
12416                                    assert(ex == "+0;0");
12417                                    assert(ios.width() == 0);
12418                                }
12419                                ios.width(25);
12420                                left(ios);
12421                                {
12422                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12423                                    std::string ex(str, iter.base());
12424                                    assert(ex == "+0;0*********************");
12425                                    assert(ios.width() == 0);
12426                                }
12427                                ios.width(25);
12428                                right(ios);
12429                                {
12430                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12431                                    std::string ex(str, iter.base());
12432                                    assert(ex == "*********************+0;0");
12433                                    assert(ios.width() == 0);
12434                                }
12435                                ios.width(25);
12436                                internal(ios);
12437                                {
12438                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12439                                    std::string ex(str, iter.base());
12440                                    assert(ex == "+*********************0;0");
12441                                    assert(ios.width() == 0);
12442                                }
12443                            }
12444                        }
12445                        showpoint(ios);
12446                        {
12447                            ios.imbue(lc);
12448                            {
12449                                ios.width(0);
12450                                {
12451                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12452                                    std::string ex(str, iter.base());
12453                                    assert(ex == "+0.0");
12454                                    assert(ios.width() == 0);
12455                                }
12456                                ios.width(25);
12457                                left(ios);
12458                                {
12459                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12460                                    std::string ex(str, iter.base());
12461                                    assert(ex == "+0.0*********************");
12462                                    assert(ios.width() == 0);
12463                                }
12464                                ios.width(25);
12465                                right(ios);
12466                                {
12467                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12468                                    std::string ex(str, iter.base());
12469                                    assert(ex == "*********************+0.0");
12470                                    assert(ios.width() == 0);
12471                                }
12472                                ios.width(25);
12473                                internal(ios);
12474                                {
12475                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12476                                    std::string ex(str, iter.base());
12477                                    assert(ex == "+*********************0.0");
12478                                    assert(ios.width() == 0);
12479                                }
12480                            }
12481                            ios.imbue(lg);
12482                            {
12483                                ios.width(0);
12484                                {
12485                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12486                                    std::string ex(str, iter.base());
12487                                    assert(ex == "+0;0");
12488                                    assert(ios.width() == 0);
12489                                }
12490                                ios.width(25);
12491                                left(ios);
12492                                {
12493                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12494                                    std::string ex(str, iter.base());
12495                                    assert(ex == "+0;0*********************");
12496                                    assert(ios.width() == 0);
12497                                }
12498                                ios.width(25);
12499                                right(ios);
12500                                {
12501                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12502                                    std::string ex(str, iter.base());
12503                                    assert(ex == "*********************+0;0");
12504                                    assert(ios.width() == 0);
12505                                }
12506                                ios.width(25);
12507                                internal(ios);
12508                                {
12509                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12510                                    std::string ex(str, iter.base());
12511                                    assert(ex == "+*********************0;0");
12512                                    assert(ios.width() == 0);
12513                                }
12514                            }
12515                        }
12516                    }
12517                }
12518            }
12519            ios.precision(6);
12520            {
12521                nouppercase(ios);
12522                {
12523                    noshowpos(ios);
12524                    {
12525                        noshowpoint(ios);
12526                        {
12527                            ios.imbue(lc);
12528                            {
12529                                ios.width(0);
12530                                {
12531                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12532                                    std::string ex(str, iter.base());
12533                                    assert(ex == "0.000000");
12534                                    assert(ios.width() == 0);
12535                                }
12536                                ios.width(25);
12537                                left(ios);
12538                                {
12539                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12540                                    std::string ex(str, iter.base());
12541                                    assert(ex == "0.000000*****************");
12542                                    assert(ios.width() == 0);
12543                                }
12544                                ios.width(25);
12545                                right(ios);
12546                                {
12547                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12548                                    std::string ex(str, iter.base());
12549                                    assert(ex == "*****************0.000000");
12550                                    assert(ios.width() == 0);
12551                                }
12552                                ios.width(25);
12553                                internal(ios);
12554                                {
12555                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12556                                    std::string ex(str, iter.base());
12557                                    assert(ex == "*****************0.000000");
12558                                    assert(ios.width() == 0);
12559                                }
12560                            }
12561                            ios.imbue(lg);
12562                            {
12563                                ios.width(0);
12564                                {
12565                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12566                                    std::string ex(str, iter.base());
12567                                    assert(ex == "0;000000");
12568                                    assert(ios.width() == 0);
12569                                }
12570                                ios.width(25);
12571                                left(ios);
12572                                {
12573                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12574                                    std::string ex(str, iter.base());
12575                                    assert(ex == "0;000000*****************");
12576                                    assert(ios.width() == 0);
12577                                }
12578                                ios.width(25);
12579                                right(ios);
12580                                {
12581                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12582                                    std::string ex(str, iter.base());
12583                                    assert(ex == "*****************0;000000");
12584                                    assert(ios.width() == 0);
12585                                }
12586                                ios.width(25);
12587                                internal(ios);
12588                                {
12589                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12590                                    std::string ex(str, iter.base());
12591                                    assert(ex == "*****************0;000000");
12592                                    assert(ios.width() == 0);
12593                                }
12594                            }
12595                        }
12596                        showpoint(ios);
12597                        {
12598                            ios.imbue(lc);
12599                            {
12600                                ios.width(0);
12601                                {
12602                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12603                                    std::string ex(str, iter.base());
12604                                    assert(ex == "0.000000");
12605                                    assert(ios.width() == 0);
12606                                }
12607                                ios.width(25);
12608                                left(ios);
12609                                {
12610                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12611                                    std::string ex(str, iter.base());
12612                                    assert(ex == "0.000000*****************");
12613                                    assert(ios.width() == 0);
12614                                }
12615                                ios.width(25);
12616                                right(ios);
12617                                {
12618                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12619                                    std::string ex(str, iter.base());
12620                                    assert(ex == "*****************0.000000");
12621                                    assert(ios.width() == 0);
12622                                }
12623                                ios.width(25);
12624                                internal(ios);
12625                                {
12626                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12627                                    std::string ex(str, iter.base());
12628                                    assert(ex == "*****************0.000000");
12629                                    assert(ios.width() == 0);
12630                                }
12631                            }
12632                            ios.imbue(lg);
12633                            {
12634                                ios.width(0);
12635                                {
12636                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12637                                    std::string ex(str, iter.base());
12638                                    assert(ex == "0;000000");
12639                                    assert(ios.width() == 0);
12640                                }
12641                                ios.width(25);
12642                                left(ios);
12643                                {
12644                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12645                                    std::string ex(str, iter.base());
12646                                    assert(ex == "0;000000*****************");
12647                                    assert(ios.width() == 0);
12648                                }
12649                                ios.width(25);
12650                                right(ios);
12651                                {
12652                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12653                                    std::string ex(str, iter.base());
12654                                    assert(ex == "*****************0;000000");
12655                                    assert(ios.width() == 0);
12656                                }
12657                                ios.width(25);
12658                                internal(ios);
12659                                {
12660                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12661                                    std::string ex(str, iter.base());
12662                                    assert(ex == "*****************0;000000");
12663                                    assert(ios.width() == 0);
12664                                }
12665                            }
12666                        }
12667                    }
12668                    showpos(ios);
12669                    {
12670                        noshowpoint(ios);
12671                        {
12672                            ios.imbue(lc);
12673                            {
12674                                ios.width(0);
12675                                {
12676                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12677                                    std::string ex(str, iter.base());
12678                                    assert(ex == "+0.000000");
12679                                    assert(ios.width() == 0);
12680                                }
12681                                ios.width(25);
12682                                left(ios);
12683                                {
12684                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12685                                    std::string ex(str, iter.base());
12686                                    assert(ex == "+0.000000****************");
12687                                    assert(ios.width() == 0);
12688                                }
12689                                ios.width(25);
12690                                right(ios);
12691                                {
12692                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12693                                    std::string ex(str, iter.base());
12694                                    assert(ex == "****************+0.000000");
12695                                    assert(ios.width() == 0);
12696                                }
12697                                ios.width(25);
12698                                internal(ios);
12699                                {
12700                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12701                                    std::string ex(str, iter.base());
12702                                    assert(ex == "+****************0.000000");
12703                                    assert(ios.width() == 0);
12704                                }
12705                            }
12706                            ios.imbue(lg);
12707                            {
12708                                ios.width(0);
12709                                {
12710                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12711                                    std::string ex(str, iter.base());
12712                                    assert(ex == "+0;000000");
12713                                    assert(ios.width() == 0);
12714                                }
12715                                ios.width(25);
12716                                left(ios);
12717                                {
12718                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12719                                    std::string ex(str, iter.base());
12720                                    assert(ex == "+0;000000****************");
12721                                    assert(ios.width() == 0);
12722                                }
12723                                ios.width(25);
12724                                right(ios);
12725                                {
12726                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12727                                    std::string ex(str, iter.base());
12728                                    assert(ex == "****************+0;000000");
12729                                    assert(ios.width() == 0);
12730                                }
12731                                ios.width(25);
12732                                internal(ios);
12733                                {
12734                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12735                                    std::string ex(str, iter.base());
12736                                    assert(ex == "+****************0;000000");
12737                                    assert(ios.width() == 0);
12738                                }
12739                            }
12740                        }
12741                        showpoint(ios);
12742                        {
12743                            ios.imbue(lc);
12744                            {
12745                                ios.width(0);
12746                                {
12747                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12748                                    std::string ex(str, iter.base());
12749                                    assert(ex == "+0.000000");
12750                                    assert(ios.width() == 0);
12751                                }
12752                                ios.width(25);
12753                                left(ios);
12754                                {
12755                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12756                                    std::string ex(str, iter.base());
12757                                    assert(ex == "+0.000000****************");
12758                                    assert(ios.width() == 0);
12759                                }
12760                                ios.width(25);
12761                                right(ios);
12762                                {
12763                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12764                                    std::string ex(str, iter.base());
12765                                    assert(ex == "****************+0.000000");
12766                                    assert(ios.width() == 0);
12767                                }
12768                                ios.width(25);
12769                                internal(ios);
12770                                {
12771                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12772                                    std::string ex(str, iter.base());
12773                                    assert(ex == "+****************0.000000");
12774                                    assert(ios.width() == 0);
12775                                }
12776                            }
12777                            ios.imbue(lg);
12778                            {
12779                                ios.width(0);
12780                                {
12781                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12782                                    std::string ex(str, iter.base());
12783                                    assert(ex == "+0;000000");
12784                                    assert(ios.width() == 0);
12785                                }
12786                                ios.width(25);
12787                                left(ios);
12788                                {
12789                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12790                                    std::string ex(str, iter.base());
12791                                    assert(ex == "+0;000000****************");
12792                                    assert(ios.width() == 0);
12793                                }
12794                                ios.width(25);
12795                                right(ios);
12796                                {
12797                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12798                                    std::string ex(str, iter.base());
12799                                    assert(ex == "****************+0;000000");
12800                                    assert(ios.width() == 0);
12801                                }
12802                                ios.width(25);
12803                                internal(ios);
12804                                {
12805                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12806                                    std::string ex(str, iter.base());
12807                                    assert(ex == "+****************0;000000");
12808                                    assert(ios.width() == 0);
12809                                }
12810                            }
12811                        }
12812                    }
12813                }
12814                uppercase(ios);
12815                {
12816                    noshowpos(ios);
12817                    {
12818                        noshowpoint(ios);
12819                        {
12820                            ios.imbue(lc);
12821                            {
12822                                ios.width(0);
12823                                {
12824                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12825                                    std::string ex(str, iter.base());
12826                                    assert(ex == "0.000000");
12827                                    assert(ios.width() == 0);
12828                                }
12829                                ios.width(25);
12830                                left(ios);
12831                                {
12832                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12833                                    std::string ex(str, iter.base());
12834                                    assert(ex == "0.000000*****************");
12835                                    assert(ios.width() == 0);
12836                                }
12837                                ios.width(25);
12838                                right(ios);
12839                                {
12840                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12841                                    std::string ex(str, iter.base());
12842                                    assert(ex == "*****************0.000000");
12843                                    assert(ios.width() == 0);
12844                                }
12845                                ios.width(25);
12846                                internal(ios);
12847                                {
12848                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12849                                    std::string ex(str, iter.base());
12850                                    assert(ex == "*****************0.000000");
12851                                    assert(ios.width() == 0);
12852                                }
12853                            }
12854                            ios.imbue(lg);
12855                            {
12856                                ios.width(0);
12857                                {
12858                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12859                                    std::string ex(str, iter.base());
12860                                    assert(ex == "0;000000");
12861                                    assert(ios.width() == 0);
12862                                }
12863                                ios.width(25);
12864                                left(ios);
12865                                {
12866                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12867                                    std::string ex(str, iter.base());
12868                                    assert(ex == "0;000000*****************");
12869                                    assert(ios.width() == 0);
12870                                }
12871                                ios.width(25);
12872                                right(ios);
12873                                {
12874                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12875                                    std::string ex(str, iter.base());
12876                                    assert(ex == "*****************0;000000");
12877                                    assert(ios.width() == 0);
12878                                }
12879                                ios.width(25);
12880                                internal(ios);
12881                                {
12882                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12883                                    std::string ex(str, iter.base());
12884                                    assert(ex == "*****************0;000000");
12885                                    assert(ios.width() == 0);
12886                                }
12887                            }
12888                        }
12889                        showpoint(ios);
12890                        {
12891                            ios.imbue(lc);
12892                            {
12893                                ios.width(0);
12894                                {
12895                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12896                                    std::string ex(str, iter.base());
12897                                    assert(ex == "0.000000");
12898                                    assert(ios.width() == 0);
12899                                }
12900                                ios.width(25);
12901                                left(ios);
12902                                {
12903                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12904                                    std::string ex(str, iter.base());
12905                                    assert(ex == "0.000000*****************");
12906                                    assert(ios.width() == 0);
12907                                }
12908                                ios.width(25);
12909                                right(ios);
12910                                {
12911                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12912                                    std::string ex(str, iter.base());
12913                                    assert(ex == "*****************0.000000");
12914                                    assert(ios.width() == 0);
12915                                }
12916                                ios.width(25);
12917                                internal(ios);
12918                                {
12919                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12920                                    std::string ex(str, iter.base());
12921                                    assert(ex == "*****************0.000000");
12922                                    assert(ios.width() == 0);
12923                                }
12924                            }
12925                            ios.imbue(lg);
12926                            {
12927                                ios.width(0);
12928                                {
12929                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12930                                    std::string ex(str, iter.base());
12931                                    assert(ex == "0;000000");
12932                                    assert(ios.width() == 0);
12933                                }
12934                                ios.width(25);
12935                                left(ios);
12936                                {
12937                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12938                                    std::string ex(str, iter.base());
12939                                    assert(ex == "0;000000*****************");
12940                                    assert(ios.width() == 0);
12941                                }
12942                                ios.width(25);
12943                                right(ios);
12944                                {
12945                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12946                                    std::string ex(str, iter.base());
12947                                    assert(ex == "*****************0;000000");
12948                                    assert(ios.width() == 0);
12949                                }
12950                                ios.width(25);
12951                                internal(ios);
12952                                {
12953                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12954                                    std::string ex(str, iter.base());
12955                                    assert(ex == "*****************0;000000");
12956                                    assert(ios.width() == 0);
12957                                }
12958                            }
12959                        }
12960                    }
12961                    showpos(ios);
12962                    {
12963                        noshowpoint(ios);
12964                        {
12965                            ios.imbue(lc);
12966                            {
12967                                ios.width(0);
12968                                {
12969                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12970                                    std::string ex(str, iter.base());
12971                                    assert(ex == "+0.000000");
12972                                    assert(ios.width() == 0);
12973                                }
12974                                ios.width(25);
12975                                left(ios);
12976                                {
12977                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12978                                    std::string ex(str, iter.base());
12979                                    assert(ex == "+0.000000****************");
12980                                    assert(ios.width() == 0);
12981                                }
12982                                ios.width(25);
12983                                right(ios);
12984                                {
12985                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12986                                    std::string ex(str, iter.base());
12987                                    assert(ex == "****************+0.000000");
12988                                    assert(ios.width() == 0);
12989                                }
12990                                ios.width(25);
12991                                internal(ios);
12992                                {
12993                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
12994                                    std::string ex(str, iter.base());
12995                                    assert(ex == "+****************0.000000");
12996                                    assert(ios.width() == 0);
12997                                }
12998                            }
12999                            ios.imbue(lg);
13000                            {
13001                                ios.width(0);
13002                                {
13003                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13004                                    std::string ex(str, iter.base());
13005                                    assert(ex == "+0;000000");
13006                                    assert(ios.width() == 0);
13007                                }
13008                                ios.width(25);
13009                                left(ios);
13010                                {
13011                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13012                                    std::string ex(str, iter.base());
13013                                    assert(ex == "+0;000000****************");
13014                                    assert(ios.width() == 0);
13015                                }
13016                                ios.width(25);
13017                                right(ios);
13018                                {
13019                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13020                                    std::string ex(str, iter.base());
13021                                    assert(ex == "****************+0;000000");
13022                                    assert(ios.width() == 0);
13023                                }
13024                                ios.width(25);
13025                                internal(ios);
13026                                {
13027                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13028                                    std::string ex(str, iter.base());
13029                                    assert(ex == "+****************0;000000");
13030                                    assert(ios.width() == 0);
13031                                }
13032                            }
13033                        }
13034                        showpoint(ios);
13035                        {
13036                            ios.imbue(lc);
13037                            {
13038                                ios.width(0);
13039                                {
13040                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13041                                    std::string ex(str, iter.base());
13042                                    assert(ex == "+0.000000");
13043                                    assert(ios.width() == 0);
13044                                }
13045                                ios.width(25);
13046                                left(ios);
13047                                {
13048                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13049                                    std::string ex(str, iter.base());
13050                                    assert(ex == "+0.000000****************");
13051                                    assert(ios.width() == 0);
13052                                }
13053                                ios.width(25);
13054                                right(ios);
13055                                {
13056                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13057                                    std::string ex(str, iter.base());
13058                                    assert(ex == "****************+0.000000");
13059                                    assert(ios.width() == 0);
13060                                }
13061                                ios.width(25);
13062                                internal(ios);
13063                                {
13064                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13065                                    std::string ex(str, iter.base());
13066                                    assert(ex == "+****************0.000000");
13067                                    assert(ios.width() == 0);
13068                                }
13069                            }
13070                            ios.imbue(lg);
13071                            {
13072                                ios.width(0);
13073                                {
13074                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13075                                    std::string ex(str, iter.base());
13076                                    assert(ex == "+0;000000");
13077                                    assert(ios.width() == 0);
13078                                }
13079                                ios.width(25);
13080                                left(ios);
13081                                {
13082                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13083                                    std::string ex(str, iter.base());
13084                                    assert(ex == "+0;000000****************");
13085                                    assert(ios.width() == 0);
13086                                }
13087                                ios.width(25);
13088                                right(ios);
13089                                {
13090                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13091                                    std::string ex(str, iter.base());
13092                                    assert(ex == "****************+0;000000");
13093                                    assert(ios.width() == 0);
13094                                }
13095                                ios.width(25);
13096                                internal(ios);
13097                                {
13098                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13099                                    std::string ex(str, iter.base());
13100                                    assert(ex == "+****************0;000000");
13101                                    assert(ios.width() == 0);
13102                                }
13103                            }
13104                        }
13105                    }
13106                }
13107            }
13108            ios.precision(16);
13109            {
13110                nouppercase(ios);
13111                {
13112                    noshowpos(ios);
13113                    {
13114                        noshowpoint(ios);
13115                        {
13116                            ios.imbue(lc);
13117                            {
13118                                ios.width(0);
13119                                {
13120                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13121                                    std::string ex(str, iter.base());
13122                                    assert(ex == "0.0000000000000000");
13123                                    assert(ios.width() == 0);
13124                                }
13125                                ios.width(25);
13126                                left(ios);
13127                                {
13128                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13129                                    std::string ex(str, iter.base());
13130                                    assert(ex == "0.0000000000000000*******");
13131                                    assert(ios.width() == 0);
13132                                }
13133                                ios.width(25);
13134                                right(ios);
13135                                {
13136                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13137                                    std::string ex(str, iter.base());
13138                                    assert(ex == "*******0.0000000000000000");
13139                                    assert(ios.width() == 0);
13140                                }
13141                                ios.width(25);
13142                                internal(ios);
13143                                {
13144                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13145                                    std::string ex(str, iter.base());
13146                                    assert(ex == "*******0.0000000000000000");
13147                                    assert(ios.width() == 0);
13148                                }
13149                            }
13150                            ios.imbue(lg);
13151                            {
13152                                ios.width(0);
13153                                {
13154                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13155                                    std::string ex(str, iter.base());
13156                                    assert(ex == "0;0000000000000000");
13157                                    assert(ios.width() == 0);
13158                                }
13159                                ios.width(25);
13160                                left(ios);
13161                                {
13162                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13163                                    std::string ex(str, iter.base());
13164                                    assert(ex == "0;0000000000000000*******");
13165                                    assert(ios.width() == 0);
13166                                }
13167                                ios.width(25);
13168                                right(ios);
13169                                {
13170                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13171                                    std::string ex(str, iter.base());
13172                                    assert(ex == "*******0;0000000000000000");
13173                                    assert(ios.width() == 0);
13174                                }
13175                                ios.width(25);
13176                                internal(ios);
13177                                {
13178                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13179                                    std::string ex(str, iter.base());
13180                                    assert(ex == "*******0;0000000000000000");
13181                                    assert(ios.width() == 0);
13182                                }
13183                            }
13184                        }
13185                        showpoint(ios);
13186                        {
13187                            ios.imbue(lc);
13188                            {
13189                                ios.width(0);
13190                                {
13191                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13192                                    std::string ex(str, iter.base());
13193                                    assert(ex == "0.0000000000000000");
13194                                    assert(ios.width() == 0);
13195                                }
13196                                ios.width(25);
13197                                left(ios);
13198                                {
13199                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13200                                    std::string ex(str, iter.base());
13201                                    assert(ex == "0.0000000000000000*******");
13202                                    assert(ios.width() == 0);
13203                                }
13204                                ios.width(25);
13205                                right(ios);
13206                                {
13207                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13208                                    std::string ex(str, iter.base());
13209                                    assert(ex == "*******0.0000000000000000");
13210                                    assert(ios.width() == 0);
13211                                }
13212                                ios.width(25);
13213                                internal(ios);
13214                                {
13215                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13216                                    std::string ex(str, iter.base());
13217                                    assert(ex == "*******0.0000000000000000");
13218                                    assert(ios.width() == 0);
13219                                }
13220                            }
13221                            ios.imbue(lg);
13222                            {
13223                                ios.width(0);
13224                                {
13225                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13226                                    std::string ex(str, iter.base());
13227                                    assert(ex == "0;0000000000000000");
13228                                    assert(ios.width() == 0);
13229                                }
13230                                ios.width(25);
13231                                left(ios);
13232                                {
13233                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13234                                    std::string ex(str, iter.base());
13235                                    assert(ex == "0;0000000000000000*******");
13236                                    assert(ios.width() == 0);
13237                                }
13238                                ios.width(25);
13239                                right(ios);
13240                                {
13241                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13242                                    std::string ex(str, iter.base());
13243                                    assert(ex == "*******0;0000000000000000");
13244                                    assert(ios.width() == 0);
13245                                }
13246                                ios.width(25);
13247                                internal(ios);
13248                                {
13249                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13250                                    std::string ex(str, iter.base());
13251                                    assert(ex == "*******0;0000000000000000");
13252                                    assert(ios.width() == 0);
13253                                }
13254                            }
13255                        }
13256                    }
13257                    showpos(ios);
13258                    {
13259                        noshowpoint(ios);
13260                        {
13261                            ios.imbue(lc);
13262                            {
13263                                ios.width(0);
13264                                {
13265                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13266                                    std::string ex(str, iter.base());
13267                                    assert(ex == "+0.0000000000000000");
13268                                    assert(ios.width() == 0);
13269                                }
13270                                ios.width(25);
13271                                left(ios);
13272                                {
13273                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13274                                    std::string ex(str, iter.base());
13275                                    assert(ex == "+0.0000000000000000******");
13276                                    assert(ios.width() == 0);
13277                                }
13278                                ios.width(25);
13279                                right(ios);
13280                                {
13281                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13282                                    std::string ex(str, iter.base());
13283                                    assert(ex == "******+0.0000000000000000");
13284                                    assert(ios.width() == 0);
13285                                }
13286                                ios.width(25);
13287                                internal(ios);
13288                                {
13289                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13290                                    std::string ex(str, iter.base());
13291                                    assert(ex == "+******0.0000000000000000");
13292                                    assert(ios.width() == 0);
13293                                }
13294                            }
13295                            ios.imbue(lg);
13296                            {
13297                                ios.width(0);
13298                                {
13299                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13300                                    std::string ex(str, iter.base());
13301                                    assert(ex == "+0;0000000000000000");
13302                                    assert(ios.width() == 0);
13303                                }
13304                                ios.width(25);
13305                                left(ios);
13306                                {
13307                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13308                                    std::string ex(str, iter.base());
13309                                    assert(ex == "+0;0000000000000000******");
13310                                    assert(ios.width() == 0);
13311                                }
13312                                ios.width(25);
13313                                right(ios);
13314                                {
13315                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13316                                    std::string ex(str, iter.base());
13317                                    assert(ex == "******+0;0000000000000000");
13318                                    assert(ios.width() == 0);
13319                                }
13320                                ios.width(25);
13321                                internal(ios);
13322                                {
13323                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13324                                    std::string ex(str, iter.base());
13325                                    assert(ex == "+******0;0000000000000000");
13326                                    assert(ios.width() == 0);
13327                                }
13328                            }
13329                        }
13330                        showpoint(ios);
13331                        {
13332                            ios.imbue(lc);
13333                            {
13334                                ios.width(0);
13335                                {
13336                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13337                                    std::string ex(str, iter.base());
13338                                    assert(ex == "+0.0000000000000000");
13339                                    assert(ios.width() == 0);
13340                                }
13341                                ios.width(25);
13342                                left(ios);
13343                                {
13344                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13345                                    std::string ex(str, iter.base());
13346                                    assert(ex == "+0.0000000000000000******");
13347                                    assert(ios.width() == 0);
13348                                }
13349                                ios.width(25);
13350                                right(ios);
13351                                {
13352                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13353                                    std::string ex(str, iter.base());
13354                                    assert(ex == "******+0.0000000000000000");
13355                                    assert(ios.width() == 0);
13356                                }
13357                                ios.width(25);
13358                                internal(ios);
13359                                {
13360                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13361                                    std::string ex(str, iter.base());
13362                                    assert(ex == "+******0.0000000000000000");
13363                                    assert(ios.width() == 0);
13364                                }
13365                            }
13366                            ios.imbue(lg);
13367                            {
13368                                ios.width(0);
13369                                {
13370                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13371                                    std::string ex(str, iter.base());
13372                                    assert(ex == "+0;0000000000000000");
13373                                    assert(ios.width() == 0);
13374                                }
13375                                ios.width(25);
13376                                left(ios);
13377                                {
13378                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13379                                    std::string ex(str, iter.base());
13380                                    assert(ex == "+0;0000000000000000******");
13381                                    assert(ios.width() == 0);
13382                                }
13383                                ios.width(25);
13384                                right(ios);
13385                                {
13386                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13387                                    std::string ex(str, iter.base());
13388                                    assert(ex == "******+0;0000000000000000");
13389                                    assert(ios.width() == 0);
13390                                }
13391                                ios.width(25);
13392                                internal(ios);
13393                                {
13394                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13395                                    std::string ex(str, iter.base());
13396                                    assert(ex == "+******0;0000000000000000");
13397                                    assert(ios.width() == 0);
13398                                }
13399                            }
13400                        }
13401                    }
13402                }
13403                uppercase(ios);
13404                {
13405                    noshowpos(ios);
13406                    {
13407                        noshowpoint(ios);
13408                        {
13409                            ios.imbue(lc);
13410                            {
13411                                ios.width(0);
13412                                {
13413                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13414                                    std::string ex(str, iter.base());
13415                                    assert(ex == "0.0000000000000000");
13416                                    assert(ios.width() == 0);
13417                                }
13418                                ios.width(25);
13419                                left(ios);
13420                                {
13421                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13422                                    std::string ex(str, iter.base());
13423                                    assert(ex == "0.0000000000000000*******");
13424                                    assert(ios.width() == 0);
13425                                }
13426                                ios.width(25);
13427                                right(ios);
13428                                {
13429                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13430                                    std::string ex(str, iter.base());
13431                                    assert(ex == "*******0.0000000000000000");
13432                                    assert(ios.width() == 0);
13433                                }
13434                                ios.width(25);
13435                                internal(ios);
13436                                {
13437                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13438                                    std::string ex(str, iter.base());
13439                                    assert(ex == "*******0.0000000000000000");
13440                                    assert(ios.width() == 0);
13441                                }
13442                            }
13443                            ios.imbue(lg);
13444                            {
13445                                ios.width(0);
13446                                {
13447                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13448                                    std::string ex(str, iter.base());
13449                                    assert(ex == "0;0000000000000000");
13450                                    assert(ios.width() == 0);
13451                                }
13452                                ios.width(25);
13453                                left(ios);
13454                                {
13455                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13456                                    std::string ex(str, iter.base());
13457                                    assert(ex == "0;0000000000000000*******");
13458                                    assert(ios.width() == 0);
13459                                }
13460                                ios.width(25);
13461                                right(ios);
13462                                {
13463                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13464                                    std::string ex(str, iter.base());
13465                                    assert(ex == "*******0;0000000000000000");
13466                                    assert(ios.width() == 0);
13467                                }
13468                                ios.width(25);
13469                                internal(ios);
13470                                {
13471                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13472                                    std::string ex(str, iter.base());
13473                                    assert(ex == "*******0;0000000000000000");
13474                                    assert(ios.width() == 0);
13475                                }
13476                            }
13477                        }
13478                        showpoint(ios);
13479                        {
13480                            ios.imbue(lc);
13481                            {
13482                                ios.width(0);
13483                                {
13484                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13485                                    std::string ex(str, iter.base());
13486                                    assert(ex == "0.0000000000000000");
13487                                    assert(ios.width() == 0);
13488                                }
13489                                ios.width(25);
13490                                left(ios);
13491                                {
13492                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13493                                    std::string ex(str, iter.base());
13494                                    assert(ex == "0.0000000000000000*******");
13495                                    assert(ios.width() == 0);
13496                                }
13497                                ios.width(25);
13498                                right(ios);
13499                                {
13500                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13501                                    std::string ex(str, iter.base());
13502                                    assert(ex == "*******0.0000000000000000");
13503                                    assert(ios.width() == 0);
13504                                }
13505                                ios.width(25);
13506                                internal(ios);
13507                                {
13508                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13509                                    std::string ex(str, iter.base());
13510                                    assert(ex == "*******0.0000000000000000");
13511                                    assert(ios.width() == 0);
13512                                }
13513                            }
13514                            ios.imbue(lg);
13515                            {
13516                                ios.width(0);
13517                                {
13518                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13519                                    std::string ex(str, iter.base());
13520                                    assert(ex == "0;0000000000000000");
13521                                    assert(ios.width() == 0);
13522                                }
13523                                ios.width(25);
13524                                left(ios);
13525                                {
13526                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13527                                    std::string ex(str, iter.base());
13528                                    assert(ex == "0;0000000000000000*******");
13529                                    assert(ios.width() == 0);
13530                                }
13531                                ios.width(25);
13532                                right(ios);
13533                                {
13534                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13535                                    std::string ex(str, iter.base());
13536                                    assert(ex == "*******0;0000000000000000");
13537                                    assert(ios.width() == 0);
13538                                }
13539                                ios.width(25);
13540                                internal(ios);
13541                                {
13542                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13543                                    std::string ex(str, iter.base());
13544                                    assert(ex == "*******0;0000000000000000");
13545                                    assert(ios.width() == 0);
13546                                }
13547                            }
13548                        }
13549                    }
13550                    showpos(ios);
13551                    {
13552                        noshowpoint(ios);
13553                        {
13554                            ios.imbue(lc);
13555                            {
13556                                ios.width(0);
13557                                {
13558                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13559                                    std::string ex(str, iter.base());
13560                                    assert(ex == "+0.0000000000000000");
13561                                    assert(ios.width() == 0);
13562                                }
13563                                ios.width(25);
13564                                left(ios);
13565                                {
13566                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13567                                    std::string ex(str, iter.base());
13568                                    assert(ex == "+0.0000000000000000******");
13569                                    assert(ios.width() == 0);
13570                                }
13571                                ios.width(25);
13572                                right(ios);
13573                                {
13574                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13575                                    std::string ex(str, iter.base());
13576                                    assert(ex == "******+0.0000000000000000");
13577                                    assert(ios.width() == 0);
13578                                }
13579                                ios.width(25);
13580                                internal(ios);
13581                                {
13582                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13583                                    std::string ex(str, iter.base());
13584                                    assert(ex == "+******0.0000000000000000");
13585                                    assert(ios.width() == 0);
13586                                }
13587                            }
13588                            ios.imbue(lg);
13589                            {
13590                                ios.width(0);
13591                                {
13592                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13593                                    std::string ex(str, iter.base());
13594                                    assert(ex == "+0;0000000000000000");
13595                                    assert(ios.width() == 0);
13596                                }
13597                                ios.width(25);
13598                                left(ios);
13599                                {
13600                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13601                                    std::string ex(str, iter.base());
13602                                    assert(ex == "+0;0000000000000000******");
13603                                    assert(ios.width() == 0);
13604                                }
13605                                ios.width(25);
13606                                right(ios);
13607                                {
13608                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13609                                    std::string ex(str, iter.base());
13610                                    assert(ex == "******+0;0000000000000000");
13611                                    assert(ios.width() == 0);
13612                                }
13613                                ios.width(25);
13614                                internal(ios);
13615                                {
13616                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13617                                    std::string ex(str, iter.base());
13618                                    assert(ex == "+******0;0000000000000000");
13619                                    assert(ios.width() == 0);
13620                                }
13621                            }
13622                        }
13623                        showpoint(ios);
13624                        {
13625                            ios.imbue(lc);
13626                            {
13627                                ios.width(0);
13628                                {
13629                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13630                                    std::string ex(str, iter.base());
13631                                    assert(ex == "+0.0000000000000000");
13632                                    assert(ios.width() == 0);
13633                                }
13634                                ios.width(25);
13635                                left(ios);
13636                                {
13637                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13638                                    std::string ex(str, iter.base());
13639                                    assert(ex == "+0.0000000000000000******");
13640                                    assert(ios.width() == 0);
13641                                }
13642                                ios.width(25);
13643                                right(ios);
13644                                {
13645                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13646                                    std::string ex(str, iter.base());
13647                                    assert(ex == "******+0.0000000000000000");
13648                                    assert(ios.width() == 0);
13649                                }
13650                                ios.width(25);
13651                                internal(ios);
13652                                {
13653                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13654                                    std::string ex(str, iter.base());
13655                                    assert(ex == "+******0.0000000000000000");
13656                                    assert(ios.width() == 0);
13657                                }
13658                            }
13659                            ios.imbue(lg);
13660                            {
13661                                ios.width(0);
13662                                {
13663                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13664                                    std::string ex(str, iter.base());
13665                                    assert(ex == "+0;0000000000000000");
13666                                    assert(ios.width() == 0);
13667                                }
13668                                ios.width(25);
13669                                left(ios);
13670                                {
13671                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13672                                    std::string ex(str, iter.base());
13673                                    assert(ex == "+0;0000000000000000******");
13674                                    assert(ios.width() == 0);
13675                                }
13676                                ios.width(25);
13677                                right(ios);
13678                                {
13679                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13680                                    std::string ex(str, iter.base());
13681                                    assert(ex == "******+0;0000000000000000");
13682                                    assert(ios.width() == 0);
13683                                }
13684                                ios.width(25);
13685                                internal(ios);
13686                                {
13687                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13688                                    std::string ex(str, iter.base());
13689                                    assert(ex == "+******0;0000000000000000");
13690                                    assert(ios.width() == 0);
13691                                }
13692                            }
13693                        }
13694                    }
13695                }
13696            }
13697            ios.precision(60);
13698            {
13699                nouppercase(ios);
13700                {
13701                    noshowpos(ios);
13702                    {
13703                        noshowpoint(ios);
13704                        {
13705                            ios.imbue(lc);
13706                            {
13707                                ios.width(0);
13708                                {
13709                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13710                                    std::string ex(str, iter.base());
13711                                    assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13712                                    assert(ios.width() == 0);
13713                                }
13714                                ios.width(25);
13715                                left(ios);
13716                                {
13717                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13718                                    std::string ex(str, iter.base());
13719                                    assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13720                                    assert(ios.width() == 0);
13721                                }
13722                                ios.width(25);
13723                                right(ios);
13724                                {
13725                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13726                                    std::string ex(str, iter.base());
13727                                    assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13728                                    assert(ios.width() == 0);
13729                                }
13730                                ios.width(25);
13731                                internal(ios);
13732                                {
13733                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13734                                    std::string ex(str, iter.base());
13735                                    assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13736                                    assert(ios.width() == 0);
13737                                }
13738                            }
13739                            ios.imbue(lg);
13740                            {
13741                                ios.width(0);
13742                                {
13743                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13744                                    std::string ex(str, iter.base());
13745                                    assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13746                                    assert(ios.width() == 0);
13747                                }
13748                                ios.width(25);
13749                                left(ios);
13750                                {
13751                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13752                                    std::string ex(str, iter.base());
13753                                    assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13754                                    assert(ios.width() == 0);
13755                                }
13756                                ios.width(25);
13757                                right(ios);
13758                                {
13759                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13760                                    std::string ex(str, iter.base());
13761                                    assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13762                                    assert(ios.width() == 0);
13763                                }
13764                                ios.width(25);
13765                                internal(ios);
13766                                {
13767                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13768                                    std::string ex(str, iter.base());
13769                                    assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13770                                    assert(ios.width() == 0);
13771                                }
13772                            }
13773                        }
13774                        showpoint(ios);
13775                        {
13776                            ios.imbue(lc);
13777                            {
13778                                ios.width(0);
13779                                {
13780                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13781                                    std::string ex(str, iter.base());
13782                                    assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13783                                    assert(ios.width() == 0);
13784                                }
13785                                ios.width(25);
13786                                left(ios);
13787                                {
13788                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13789                                    std::string ex(str, iter.base());
13790                                    assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13791                                    assert(ios.width() == 0);
13792                                }
13793                                ios.width(25);
13794                                right(ios);
13795                                {
13796                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13797                                    std::string ex(str, iter.base());
13798                                    assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13799                                    assert(ios.width() == 0);
13800                                }
13801                                ios.width(25);
13802                                internal(ios);
13803                                {
13804                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13805                                    std::string ex(str, iter.base());
13806                                    assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
13807                                    assert(ios.width() == 0);
13808                                }
13809                            }
13810                            ios.imbue(lg);
13811                            {
13812                                ios.width(0);
13813                                {
13814                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13815                                    std::string ex(str, iter.base());
13816                                    assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13817                                    assert(ios.width() == 0);
13818                                }
13819                                ios.width(25);
13820                                left(ios);
13821                                {
13822                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13823                                    std::string ex(str, iter.base());
13824                                    assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13825                                    assert(ios.width() == 0);
13826                                }
13827                                ios.width(25);
13828                                right(ios);
13829                                {
13830                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13831                                    std::string ex(str, iter.base());
13832                                    assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13833                                    assert(ios.width() == 0);
13834                                }
13835                                ios.width(25);
13836                                internal(ios);
13837                                {
13838                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13839                                    std::string ex(str, iter.base());
13840                                    assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
13841                                    assert(ios.width() == 0);
13842                                }
13843                            }
13844                        }
13845                    }
13846                    showpos(ios);
13847                    {
13848                        noshowpoint(ios);
13849                        {
13850                            ios.imbue(lc);
13851                            {
13852                                ios.width(0);
13853                                {
13854                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13855                                    std::string ex(str, iter.base());
13856                                    assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13857                                    assert(ios.width() == 0);
13858                                }
13859                                ios.width(25);
13860                                left(ios);
13861                                {
13862                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13863                                    std::string ex(str, iter.base());
13864                                    assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13865                                    assert(ios.width() == 0);
13866                                }
13867                                ios.width(25);
13868                                right(ios);
13869                                {
13870                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13871                                    std::string ex(str, iter.base());
13872                                    assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13873                                    assert(ios.width() == 0);
13874                                }
13875                                ios.width(25);
13876                                internal(ios);
13877                                {
13878                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13879                                    std::string ex(str, iter.base());
13880                                    assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13881                                    assert(ios.width() == 0);
13882                                }
13883                            }
13884                            ios.imbue(lg);
13885                            {
13886                                ios.width(0);
13887                                {
13888                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13889                                    std::string ex(str, iter.base());
13890                                    assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13891                                    assert(ios.width() == 0);
13892                                }
13893                                ios.width(25);
13894                                left(ios);
13895                                {
13896                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13897                                    std::string ex(str, iter.base());
13898                                    assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13899                                    assert(ios.width() == 0);
13900                                }
13901                                ios.width(25);
13902                                right(ios);
13903                                {
13904                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13905                                    std::string ex(str, iter.base());
13906                                    assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13907                                    assert(ios.width() == 0);
13908                                }
13909                                ios.width(25);
13910                                internal(ios);
13911                                {
13912                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13913                                    std::string ex(str, iter.base());
13914                                    assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13915                                    assert(ios.width() == 0);
13916                                }
13917                            }
13918                        }
13919                        showpoint(ios);
13920                        {
13921                            ios.imbue(lc);
13922                            {
13923                                ios.width(0);
13924                                {
13925                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13926                                    std::string ex(str, iter.base());
13927                                    assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13928                                    assert(ios.width() == 0);
13929                                }
13930                                ios.width(25);
13931                                left(ios);
13932                                {
13933                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13934                                    std::string ex(str, iter.base());
13935                                    assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13936                                    assert(ios.width() == 0);
13937                                }
13938                                ios.width(25);
13939                                right(ios);
13940                                {
13941                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13942                                    std::string ex(str, iter.base());
13943                                    assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13944                                    assert(ios.width() == 0);
13945                                }
13946                                ios.width(25);
13947                                internal(ios);
13948                                {
13949                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13950                                    std::string ex(str, iter.base());
13951                                    assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
13952                                    assert(ios.width() == 0);
13953                                }
13954                            }
13955                            ios.imbue(lg);
13956                            {
13957                                ios.width(0);
13958                                {
13959                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13960                                    std::string ex(str, iter.base());
13961                                    assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13962                                    assert(ios.width() == 0);
13963                                }
13964                                ios.width(25);
13965                                left(ios);
13966                                {
13967                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13968                                    std::string ex(str, iter.base());
13969                                    assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13970                                    assert(ios.width() == 0);
13971                                }
13972                                ios.width(25);
13973                                right(ios);
13974                                {
13975                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13976                                    std::string ex(str, iter.base());
13977                                    assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13978                                    assert(ios.width() == 0);
13979                                }
13980                                ios.width(25);
13981                                internal(ios);
13982                                {
13983                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
13984                                    std::string ex(str, iter.base());
13985                                    assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
13986                                    assert(ios.width() == 0);
13987                                }
13988                            }
13989                        }
13990                    }
13991                }
13992                uppercase(ios);
13993                {
13994                    noshowpos(ios);
13995                    {
13996                        noshowpoint(ios);
13997                        {
13998                            ios.imbue(lc);
13999                            {
14000                                ios.width(0);
14001                                {
14002                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14003                                    std::string ex(str, iter.base());
14004                                    assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14005                                    assert(ios.width() == 0);
14006                                }
14007                                ios.width(25);
14008                                left(ios);
14009                                {
14010                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14011                                    std::string ex(str, iter.base());
14012                                    assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14013                                    assert(ios.width() == 0);
14014                                }
14015                                ios.width(25);
14016                                right(ios);
14017                                {
14018                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14019                                    std::string ex(str, iter.base());
14020                                    assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14021                                    assert(ios.width() == 0);
14022                                }
14023                                ios.width(25);
14024                                internal(ios);
14025                                {
14026                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14027                                    std::string ex(str, iter.base());
14028                                    assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14029                                    assert(ios.width() == 0);
14030                                }
14031                            }
14032                            ios.imbue(lg);
14033                            {
14034                                ios.width(0);
14035                                {
14036                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14037                                    std::string ex(str, iter.base());
14038                                    assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14039                                    assert(ios.width() == 0);
14040                                }
14041                                ios.width(25);
14042                                left(ios);
14043                                {
14044                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14045                                    std::string ex(str, iter.base());
14046                                    assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14047                                    assert(ios.width() == 0);
14048                                }
14049                                ios.width(25);
14050                                right(ios);
14051                                {
14052                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14053                                    std::string ex(str, iter.base());
14054                                    assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14055                                    assert(ios.width() == 0);
14056                                }
14057                                ios.width(25);
14058                                internal(ios);
14059                                {
14060                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14061                                    std::string ex(str, iter.base());
14062                                    assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14063                                    assert(ios.width() == 0);
14064                                }
14065                            }
14066                        }
14067                        showpoint(ios);
14068                        {
14069                            ios.imbue(lc);
14070                            {
14071                                ios.width(0);
14072                                {
14073                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14074                                    std::string ex(str, iter.base());
14075                                    assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14076                                    assert(ios.width() == 0);
14077                                }
14078                                ios.width(25);
14079                                left(ios);
14080                                {
14081                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14082                                    std::string ex(str, iter.base());
14083                                    assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14084                                    assert(ios.width() == 0);
14085                                }
14086                                ios.width(25);
14087                                right(ios);
14088                                {
14089                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14090                                    std::string ex(str, iter.base());
14091                                    assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14092                                    assert(ios.width() == 0);
14093                                }
14094                                ios.width(25);
14095                                internal(ios);
14096                                {
14097                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14098                                    std::string ex(str, iter.base());
14099                                    assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
14100                                    assert(ios.width() == 0);
14101                                }
14102                            }
14103                            ios.imbue(lg);
14104                            {
14105                                ios.width(0);
14106                                {
14107                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14108                                    std::string ex(str, iter.base());
14109                                    assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14110                                    assert(ios.width() == 0);
14111                                }
14112                                ios.width(25);
14113                                left(ios);
14114                                {
14115                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14116                                    std::string ex(str, iter.base());
14117                                    assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14118                                    assert(ios.width() == 0);
14119                                }
14120                                ios.width(25);
14121                                right(ios);
14122                                {
14123                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14124                                    std::string ex(str, iter.base());
14125                                    assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14126                                    assert(ios.width() == 0);
14127                                }
14128                                ios.width(25);
14129                                internal(ios);
14130                                {
14131                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14132                                    std::string ex(str, iter.base());
14133                                    assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
14134                                    assert(ios.width() == 0);
14135                                }
14136                            }
14137                        }
14138                    }
14139                    showpos(ios);
14140                    {
14141                        noshowpoint(ios);
14142                        {
14143                            ios.imbue(lc);
14144                            {
14145                                ios.width(0);
14146                                {
14147                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14148                                    std::string ex(str, iter.base());
14149                                    assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14150                                    assert(ios.width() == 0);
14151                                }
14152                                ios.width(25);
14153                                left(ios);
14154                                {
14155                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14156                                    std::string ex(str, iter.base());
14157                                    assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14158                                    assert(ios.width() == 0);
14159                                }
14160                                ios.width(25);
14161                                right(ios);
14162                                {
14163                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14164                                    std::string ex(str, iter.base());
14165                                    assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14166                                    assert(ios.width() == 0);
14167                                }
14168                                ios.width(25);
14169                                internal(ios);
14170                                {
14171                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14172                                    std::string ex(str, iter.base());
14173                                    assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14174                                    assert(ios.width() == 0);
14175                                }
14176                            }
14177                            ios.imbue(lg);
14178                            {
14179                                ios.width(0);
14180                                {
14181                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14182                                    std::string ex(str, iter.base());
14183                                    assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14184                                    assert(ios.width() == 0);
14185                                }
14186                                ios.width(25);
14187                                left(ios);
14188                                {
14189                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14190                                    std::string ex(str, iter.base());
14191                                    assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14192                                    assert(ios.width() == 0);
14193                                }
14194                                ios.width(25);
14195                                right(ios);
14196                                {
14197                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14198                                    std::string ex(str, iter.base());
14199                                    assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14200                                    assert(ios.width() == 0);
14201                                }
14202                                ios.width(25);
14203                                internal(ios);
14204                                {
14205                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14206                                    std::string ex(str, iter.base());
14207                                    assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14208                                    assert(ios.width() == 0);
14209                                }
14210                            }
14211                        }
14212                        showpoint(ios);
14213                        {
14214                            ios.imbue(lc);
14215                            {
14216                                ios.width(0);
14217                                {
14218                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14219                                    std::string ex(str, iter.base());
14220                                    assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14221                                    assert(ios.width() == 0);
14222                                }
14223                                ios.width(25);
14224                                left(ios);
14225                                {
14226                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14227                                    std::string ex(str, iter.base());
14228                                    assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14229                                    assert(ios.width() == 0);
14230                                }
14231                                ios.width(25);
14232                                right(ios);
14233                                {
14234                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14235                                    std::string ex(str, iter.base());
14236                                    assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14237                                    assert(ios.width() == 0);
14238                                }
14239                                ios.width(25);
14240                                internal(ios);
14241                                {
14242                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14243                                    std::string ex(str, iter.base());
14244                                    assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
14245                                    assert(ios.width() == 0);
14246                                }
14247                            }
14248                            ios.imbue(lg);
14249                            {
14250                                ios.width(0);
14251                                {
14252                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14253                                    std::string ex(str, iter.base());
14254                                    assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14255                                    assert(ios.width() == 0);
14256                                }
14257                                ios.width(25);
14258                                left(ios);
14259                                {
14260                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14261                                    std::string ex(str, iter.base());
14262                                    assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14263                                    assert(ios.width() == 0);
14264                                }
14265                                ios.width(25);
14266                                right(ios);
14267                                {
14268                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14269                                    std::string ex(str, iter.base());
14270                                    assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14271                                    assert(ios.width() == 0);
14272                                }
14273                                ios.width(25);
14274                                internal(ios);
14275                                {
14276                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14277                                    std::string ex(str, iter.base());
14278                                    assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
14279                                    assert(ios.width() == 0);
14280                                }
14281                            }
14282                        }
14283                    }
14284                }
14285            }
14286        }
14287    }
14288}
14289
14290void test7()
14291{
14292    char str[200];
14293    output_iterator<char*> iter;
14294    std::locale lc = std::locale::classic();
14295    std::locale lg(lc, new my_numpunct);
14296    const my_facet f(1);
14297    {
14298        long double v = -0.;
14299        std::ios ios(0);
14300        fixed(ios);
14301        // %f
14302        {
14303            ios.precision(0);
14304            {
14305                nouppercase(ios);
14306                {
14307                    noshowpos(ios);
14308                    {
14309                        noshowpoint(ios);
14310                        {
14311                            ios.imbue(lc);
14312                            {
14313                                ios.width(0);
14314                                {
14315                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14316                                    std::string ex(str, iter.base());
14317                                    assert(ex == "-0");
14318                                    assert(ios.width() == 0);
14319                                }
14320                                ios.width(25);
14321                                left(ios);
14322                                {
14323                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14324                                    std::string ex(str, iter.base());
14325                                    assert(ex == "-0***********************");
14326                                    assert(ios.width() == 0);
14327                                }
14328                                ios.width(25);
14329                                right(ios);
14330                                {
14331                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14332                                    std::string ex(str, iter.base());
14333                                    assert(ex == "***********************-0");
14334                                    assert(ios.width() == 0);
14335                                }
14336                                ios.width(25);
14337                                internal(ios);
14338                                {
14339                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14340                                    std::string ex(str, iter.base());
14341                                    assert(ex == "-***********************0");
14342                                    assert(ios.width() == 0);
14343                                }
14344                            }
14345                            ios.imbue(lg);
14346                            {
14347                                ios.width(0);
14348                                {
14349                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14350                                    std::string ex(str, iter.base());
14351                                    assert(ex == "-0");
14352                                    assert(ios.width() == 0);
14353                                }
14354                                ios.width(25);
14355                                left(ios);
14356                                {
14357                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14358                                    std::string ex(str, iter.base());
14359                                    assert(ex == "-0***********************");
14360                                    assert(ios.width() == 0);
14361                                }
14362                                ios.width(25);
14363                                right(ios);
14364                                {
14365                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14366                                    std::string ex(str, iter.base());
14367                                    assert(ex == "***********************-0");
14368                                    assert(ios.width() == 0);
14369                                }
14370                                ios.width(25);
14371                                internal(ios);
14372                                {
14373                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14374                                    std::string ex(str, iter.base());
14375                                    assert(ex == "-***********************0");
14376                                    assert(ios.width() == 0);
14377                                }
14378                            }
14379                        }
14380                        showpoint(ios);
14381                        {
14382                            ios.imbue(lc);
14383                            {
14384                                ios.width(0);
14385                                {
14386                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14387                                    std::string ex(str, iter.base());
14388                                    assert(ex == "-0.");
14389                                    assert(ios.width() == 0);
14390                                }
14391                                ios.width(25);
14392                                left(ios);
14393                                {
14394                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14395                                    std::string ex(str, iter.base());
14396                                    assert(ex == "-0.**********************");
14397                                    assert(ios.width() == 0);
14398                                }
14399                                ios.width(25);
14400                                right(ios);
14401                                {
14402                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14403                                    std::string ex(str, iter.base());
14404                                    assert(ex == "**********************-0.");
14405                                    assert(ios.width() == 0);
14406                                }
14407                                ios.width(25);
14408                                internal(ios);
14409                                {
14410                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14411                                    std::string ex(str, iter.base());
14412                                    assert(ex == "-**********************0.");
14413                                    assert(ios.width() == 0);
14414                                }
14415                            }
14416                            ios.imbue(lg);
14417                            {
14418                                ios.width(0);
14419                                {
14420                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14421                                    std::string ex(str, iter.base());
14422                                    assert(ex == "-0;");
14423                                    assert(ios.width() == 0);
14424                                }
14425                                ios.width(25);
14426                                left(ios);
14427                                {
14428                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14429                                    std::string ex(str, iter.base());
14430                                    assert(ex == "-0;**********************");
14431                                    assert(ios.width() == 0);
14432                                }
14433                                ios.width(25);
14434                                right(ios);
14435                                {
14436                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14437                                    std::string ex(str, iter.base());
14438                                    assert(ex == "**********************-0;");
14439                                    assert(ios.width() == 0);
14440                                }
14441                                ios.width(25);
14442                                internal(ios);
14443                                {
14444                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14445                                    std::string ex(str, iter.base());
14446                                    assert(ex == "-**********************0;");
14447                                    assert(ios.width() == 0);
14448                                }
14449                            }
14450                        }
14451                    }
14452                    showpos(ios);
14453                    {
14454                        noshowpoint(ios);
14455                        {
14456                            ios.imbue(lc);
14457                            {
14458                                ios.width(0);
14459                                {
14460                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14461                                    std::string ex(str, iter.base());
14462                                    assert(ex == "-0");
14463                                    assert(ios.width() == 0);
14464                                }
14465                                ios.width(25);
14466                                left(ios);
14467                                {
14468                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14469                                    std::string ex(str, iter.base());
14470                                    assert(ex == "-0***********************");
14471                                    assert(ios.width() == 0);
14472                                }
14473                                ios.width(25);
14474                                right(ios);
14475                                {
14476                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14477                                    std::string ex(str, iter.base());
14478                                    assert(ex == "***********************-0");
14479                                    assert(ios.width() == 0);
14480                                }
14481                                ios.width(25);
14482                                internal(ios);
14483                                {
14484                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14485                                    std::string ex(str, iter.base());
14486                                    assert(ex == "-***********************0");
14487                                    assert(ios.width() == 0);
14488                                }
14489                            }
14490                            ios.imbue(lg);
14491                            {
14492                                ios.width(0);
14493                                {
14494                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14495                                    std::string ex(str, iter.base());
14496                                    assert(ex == "-0");
14497                                    assert(ios.width() == 0);
14498                                }
14499                                ios.width(25);
14500                                left(ios);
14501                                {
14502                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14503                                    std::string ex(str, iter.base());
14504                                    assert(ex == "-0***********************");
14505                                    assert(ios.width() == 0);
14506                                }
14507                                ios.width(25);
14508                                right(ios);
14509                                {
14510                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14511                                    std::string ex(str, iter.base());
14512                                    assert(ex == "***********************-0");
14513                                    assert(ios.width() == 0);
14514                                }
14515                                ios.width(25);
14516                                internal(ios);
14517                                {
14518                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14519                                    std::string ex(str, iter.base());
14520                                    assert(ex == "-***********************0");
14521                                    assert(ios.width() == 0);
14522                                }
14523                            }
14524                        }
14525                        showpoint(ios);
14526                        {
14527                            ios.imbue(lc);
14528                            {
14529                                ios.width(0);
14530                                {
14531                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14532                                    std::string ex(str, iter.base());
14533                                    assert(ex == "-0.");
14534                                    assert(ios.width() == 0);
14535                                }
14536                                ios.width(25);
14537                                left(ios);
14538                                {
14539                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14540                                    std::string ex(str, iter.base());
14541                                    assert(ex == "-0.**********************");
14542                                    assert(ios.width() == 0);
14543                                }
14544                                ios.width(25);
14545                                right(ios);
14546                                {
14547                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14548                                    std::string ex(str, iter.base());
14549                                    assert(ex == "**********************-0.");
14550                                    assert(ios.width() == 0);
14551                                }
14552                                ios.width(25);
14553                                internal(ios);
14554                                {
14555                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14556                                    std::string ex(str, iter.base());
14557                                    assert(ex == "-**********************0.");
14558                                    assert(ios.width() == 0);
14559                                }
14560                            }
14561                            ios.imbue(lg);
14562                            {
14563                                ios.width(0);
14564                                {
14565                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14566                                    std::string ex(str, iter.base());
14567                                    assert(ex == "-0;");
14568                                    assert(ios.width() == 0);
14569                                }
14570                                ios.width(25);
14571                                left(ios);
14572                                {
14573                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14574                                    std::string ex(str, iter.base());
14575                                    assert(ex == "-0;**********************");
14576                                    assert(ios.width() == 0);
14577                                }
14578                                ios.width(25);
14579                                right(ios);
14580                                {
14581                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14582                                    std::string ex(str, iter.base());
14583                                    assert(ex == "**********************-0;");
14584                                    assert(ios.width() == 0);
14585                                }
14586                                ios.width(25);
14587                                internal(ios);
14588                                {
14589                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14590                                    std::string ex(str, iter.base());
14591                                    assert(ex == "-**********************0;");
14592                                    assert(ios.width() == 0);
14593                                }
14594                            }
14595                        }
14596                    }
14597                }
14598                uppercase(ios);
14599                {
14600                    noshowpos(ios);
14601                    {
14602                        noshowpoint(ios);
14603                        {
14604                            ios.imbue(lc);
14605                            {
14606                                ios.width(0);
14607                                {
14608                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14609                                    std::string ex(str, iter.base());
14610                                    assert(ex == "-0");
14611                                    assert(ios.width() == 0);
14612                                }
14613                                ios.width(25);
14614                                left(ios);
14615                                {
14616                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14617                                    std::string ex(str, iter.base());
14618                                    assert(ex == "-0***********************");
14619                                    assert(ios.width() == 0);
14620                                }
14621                                ios.width(25);
14622                                right(ios);
14623                                {
14624                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14625                                    std::string ex(str, iter.base());
14626                                    assert(ex == "***********************-0");
14627                                    assert(ios.width() == 0);
14628                                }
14629                                ios.width(25);
14630                                internal(ios);
14631                                {
14632                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14633                                    std::string ex(str, iter.base());
14634                                    assert(ex == "-***********************0");
14635                                    assert(ios.width() == 0);
14636                                }
14637                            }
14638                            ios.imbue(lg);
14639                            {
14640                                ios.width(0);
14641                                {
14642                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14643                                    std::string ex(str, iter.base());
14644                                    assert(ex == "-0");
14645                                    assert(ios.width() == 0);
14646                                }
14647                                ios.width(25);
14648                                left(ios);
14649                                {
14650                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14651                                    std::string ex(str, iter.base());
14652                                    assert(ex == "-0***********************");
14653                                    assert(ios.width() == 0);
14654                                }
14655                                ios.width(25);
14656                                right(ios);
14657                                {
14658                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14659                                    std::string ex(str, iter.base());
14660                                    assert(ex == "***********************-0");
14661                                    assert(ios.width() == 0);
14662                                }
14663                                ios.width(25);
14664                                internal(ios);
14665                                {
14666                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14667                                    std::string ex(str, iter.base());
14668                                    assert(ex == "-***********************0");
14669                                    assert(ios.width() == 0);
14670                                }
14671                            }
14672                        }
14673                        showpoint(ios);
14674                        {
14675                            ios.imbue(lc);
14676                            {
14677                                ios.width(0);
14678                                {
14679                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14680                                    std::string ex(str, iter.base());
14681                                    assert(ex == "-0.");
14682                                    assert(ios.width() == 0);
14683                                }
14684                                ios.width(25);
14685                                left(ios);
14686                                {
14687                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14688                                    std::string ex(str, iter.base());
14689                                    assert(ex == "-0.**********************");
14690                                    assert(ios.width() == 0);
14691                                }
14692                                ios.width(25);
14693                                right(ios);
14694                                {
14695                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14696                                    std::string ex(str, iter.base());
14697                                    assert(ex == "**********************-0.");
14698                                    assert(ios.width() == 0);
14699                                }
14700                                ios.width(25);
14701                                internal(ios);
14702                                {
14703                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14704                                    std::string ex(str, iter.base());
14705                                    assert(ex == "-**********************0.");
14706                                    assert(ios.width() == 0);
14707                                }
14708                            }
14709                            ios.imbue(lg);
14710                            {
14711                                ios.width(0);
14712                                {
14713                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14714                                    std::string ex(str, iter.base());
14715                                    assert(ex == "-0;");
14716                                    assert(ios.width() == 0);
14717                                }
14718                                ios.width(25);
14719                                left(ios);
14720                                {
14721                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14722                                    std::string ex(str, iter.base());
14723                                    assert(ex == "-0;**********************");
14724                                    assert(ios.width() == 0);
14725                                }
14726                                ios.width(25);
14727                                right(ios);
14728                                {
14729                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14730                                    std::string ex(str, iter.base());
14731                                    assert(ex == "**********************-0;");
14732                                    assert(ios.width() == 0);
14733                                }
14734                                ios.width(25);
14735                                internal(ios);
14736                                {
14737                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14738                                    std::string ex(str, iter.base());
14739                                    assert(ex == "-**********************0;");
14740                                    assert(ios.width() == 0);
14741                                }
14742                            }
14743                        }
14744                    }
14745                    showpos(ios);
14746                    {
14747                        noshowpoint(ios);
14748                        {
14749                            ios.imbue(lc);
14750                            {
14751                                ios.width(0);
14752                                {
14753                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14754                                    std::string ex(str, iter.base());
14755                                    assert(ex == "-0");
14756                                    assert(ios.width() == 0);
14757                                }
14758                                ios.width(25);
14759                                left(ios);
14760                                {
14761                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14762                                    std::string ex(str, iter.base());
14763                                    assert(ex == "-0***********************");
14764                                    assert(ios.width() == 0);
14765                                }
14766                                ios.width(25);
14767                                right(ios);
14768                                {
14769                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14770                                    std::string ex(str, iter.base());
14771                                    assert(ex == "***********************-0");
14772                                    assert(ios.width() == 0);
14773                                }
14774                                ios.width(25);
14775                                internal(ios);
14776                                {
14777                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14778                                    std::string ex(str, iter.base());
14779                                    assert(ex == "-***********************0");
14780                                    assert(ios.width() == 0);
14781                                }
14782                            }
14783                            ios.imbue(lg);
14784                            {
14785                                ios.width(0);
14786                                {
14787                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14788                                    std::string ex(str, iter.base());
14789                                    assert(ex == "-0");
14790                                    assert(ios.width() == 0);
14791                                }
14792                                ios.width(25);
14793                                left(ios);
14794                                {
14795                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14796                                    std::string ex(str, iter.base());
14797                                    assert(ex == "-0***********************");
14798                                    assert(ios.width() == 0);
14799                                }
14800                                ios.width(25);
14801                                right(ios);
14802                                {
14803                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14804                                    std::string ex(str, iter.base());
14805                                    assert(ex == "***********************-0");
14806                                    assert(ios.width() == 0);
14807                                }
14808                                ios.width(25);
14809                                internal(ios);
14810                                {
14811                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14812                                    std::string ex(str, iter.base());
14813                                    assert(ex == "-***********************0");
14814                                    assert(ios.width() == 0);
14815                                }
14816                            }
14817                        }
14818                        showpoint(ios);
14819                        {
14820                            ios.imbue(lc);
14821                            {
14822                                ios.width(0);
14823                                {
14824                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14825                                    std::string ex(str, iter.base());
14826                                    assert(ex == "-0.");
14827                                    assert(ios.width() == 0);
14828                                }
14829                                ios.width(25);
14830                                left(ios);
14831                                {
14832                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14833                                    std::string ex(str, iter.base());
14834                                    assert(ex == "-0.**********************");
14835                                    assert(ios.width() == 0);
14836                                }
14837                                ios.width(25);
14838                                right(ios);
14839                                {
14840                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14841                                    std::string ex(str, iter.base());
14842                                    assert(ex == "**********************-0.");
14843                                    assert(ios.width() == 0);
14844                                }
14845                                ios.width(25);
14846                                internal(ios);
14847                                {
14848                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14849                                    std::string ex(str, iter.base());
14850                                    assert(ex == "-**********************0.");
14851                                    assert(ios.width() == 0);
14852                                }
14853                            }
14854                            ios.imbue(lg);
14855                            {
14856                                ios.width(0);
14857                                {
14858                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14859                                    std::string ex(str, iter.base());
14860                                    assert(ex == "-0;");
14861                                    assert(ios.width() == 0);
14862                                }
14863                                ios.width(25);
14864                                left(ios);
14865                                {
14866                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14867                                    std::string ex(str, iter.base());
14868                                    assert(ex == "-0;**********************");
14869                                    assert(ios.width() == 0);
14870                                }
14871                                ios.width(25);
14872                                right(ios);
14873                                {
14874                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14875                                    std::string ex(str, iter.base());
14876                                    assert(ex == "**********************-0;");
14877                                    assert(ios.width() == 0);
14878                                }
14879                                ios.width(25);
14880                                internal(ios);
14881                                {
14882                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14883                                    std::string ex(str, iter.base());
14884                                    assert(ex == "-**********************0;");
14885                                    assert(ios.width() == 0);
14886                                }
14887                            }
14888                        }
14889                    }
14890                }
14891            }
14892            ios.precision(1);
14893            {
14894                nouppercase(ios);
14895                {
14896                    noshowpos(ios);
14897                    {
14898                        noshowpoint(ios);
14899                        {
14900                            ios.imbue(lc);
14901                            {
14902                                ios.width(0);
14903                                {
14904                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14905                                    std::string ex(str, iter.base());
14906                                    assert(ex == "-0.0");
14907                                    assert(ios.width() == 0);
14908                                }
14909                                ios.width(25);
14910                                left(ios);
14911                                {
14912                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14913                                    std::string ex(str, iter.base());
14914                                    assert(ex == "-0.0*********************");
14915                                    assert(ios.width() == 0);
14916                                }
14917                                ios.width(25);
14918                                right(ios);
14919                                {
14920                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14921                                    std::string ex(str, iter.base());
14922                                    assert(ex == "*********************-0.0");
14923                                    assert(ios.width() == 0);
14924                                }
14925                                ios.width(25);
14926                                internal(ios);
14927                                {
14928                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14929                                    std::string ex(str, iter.base());
14930                                    assert(ex == "-*********************0.0");
14931                                    assert(ios.width() == 0);
14932                                }
14933                            }
14934                            ios.imbue(lg);
14935                            {
14936                                ios.width(0);
14937                                {
14938                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14939                                    std::string ex(str, iter.base());
14940                                    assert(ex == "-0;0");
14941                                    assert(ios.width() == 0);
14942                                }
14943                                ios.width(25);
14944                                left(ios);
14945                                {
14946                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14947                                    std::string ex(str, iter.base());
14948                                    assert(ex == "-0;0*********************");
14949                                    assert(ios.width() == 0);
14950                                }
14951                                ios.width(25);
14952                                right(ios);
14953                                {
14954                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14955                                    std::string ex(str, iter.base());
14956                                    assert(ex == "*********************-0;0");
14957                                    assert(ios.width() == 0);
14958                                }
14959                                ios.width(25);
14960                                internal(ios);
14961                                {
14962                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14963                                    std::string ex(str, iter.base());
14964                                    assert(ex == "-*********************0;0");
14965                                    assert(ios.width() == 0);
14966                                }
14967                            }
14968                        }
14969                        showpoint(ios);
14970                        {
14971                            ios.imbue(lc);
14972                            {
14973                                ios.width(0);
14974                                {
14975                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14976                                    std::string ex(str, iter.base());
14977                                    assert(ex == "-0.0");
14978                                    assert(ios.width() == 0);
14979                                }
14980                                ios.width(25);
14981                                left(ios);
14982                                {
14983                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14984                                    std::string ex(str, iter.base());
14985                                    assert(ex == "-0.0*********************");
14986                                    assert(ios.width() == 0);
14987                                }
14988                                ios.width(25);
14989                                right(ios);
14990                                {
14991                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
14992                                    std::string ex(str, iter.base());
14993                                    assert(ex == "*********************-0.0");
14994                                    assert(ios.width() == 0);
14995                                }
14996                                ios.width(25);
14997                                internal(ios);
14998                                {
14999                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15000                                    std::string ex(str, iter.base());
15001                                    assert(ex == "-*********************0.0");
15002                                    assert(ios.width() == 0);
15003                                }
15004                            }
15005                            ios.imbue(lg);
15006                            {
15007                                ios.width(0);
15008                                {
15009                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15010                                    std::string ex(str, iter.base());
15011                                    assert(ex == "-0;0");
15012                                    assert(ios.width() == 0);
15013                                }
15014                                ios.width(25);
15015                                left(ios);
15016                                {
15017                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15018                                    std::string ex(str, iter.base());
15019                                    assert(ex == "-0;0*********************");
15020                                    assert(ios.width() == 0);
15021                                }
15022                                ios.width(25);
15023                                right(ios);
15024                                {
15025                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15026                                    std::string ex(str, iter.base());
15027                                    assert(ex == "*********************-0;0");
15028                                    assert(ios.width() == 0);
15029                                }
15030                                ios.width(25);
15031                                internal(ios);
15032                                {
15033                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15034                                    std::string ex(str, iter.base());
15035                                    assert(ex == "-*********************0;0");
15036                                    assert(ios.width() == 0);
15037                                }
15038                            }
15039                        }
15040                    }
15041                    showpos(ios);
15042                    {
15043                        noshowpoint(ios);
15044                        {
15045                            ios.imbue(lc);
15046                            {
15047                                ios.width(0);
15048                                {
15049                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15050                                    std::string ex(str, iter.base());
15051                                    assert(ex == "-0.0");
15052                                    assert(ios.width() == 0);
15053                                }
15054                                ios.width(25);
15055                                left(ios);
15056                                {
15057                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15058                                    std::string ex(str, iter.base());
15059                                    assert(ex == "-0.0*********************");
15060                                    assert(ios.width() == 0);
15061                                }
15062                                ios.width(25);
15063                                right(ios);
15064                                {
15065                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15066                                    std::string ex(str, iter.base());
15067                                    assert(ex == "*********************-0.0");
15068                                    assert(ios.width() == 0);
15069                                }
15070                                ios.width(25);
15071                                internal(ios);
15072                                {
15073                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15074                                    std::string ex(str, iter.base());
15075                                    assert(ex == "-*********************0.0");
15076                                    assert(ios.width() == 0);
15077                                }
15078                            }
15079                            ios.imbue(lg);
15080                            {
15081                                ios.width(0);
15082                                {
15083                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15084                                    std::string ex(str, iter.base());
15085                                    assert(ex == "-0;0");
15086                                    assert(ios.width() == 0);
15087                                }
15088                                ios.width(25);
15089                                left(ios);
15090                                {
15091                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15092                                    std::string ex(str, iter.base());
15093                                    assert(ex == "-0;0*********************");
15094                                    assert(ios.width() == 0);
15095                                }
15096                                ios.width(25);
15097                                right(ios);
15098                                {
15099                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15100                                    std::string ex(str, iter.base());
15101                                    assert(ex == "*********************-0;0");
15102                                    assert(ios.width() == 0);
15103                                }
15104                                ios.width(25);
15105                                internal(ios);
15106                                {
15107                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15108                                    std::string ex(str, iter.base());
15109                                    assert(ex == "-*********************0;0");
15110                                    assert(ios.width() == 0);
15111                                }
15112                            }
15113                        }
15114                        showpoint(ios);
15115                        {
15116                            ios.imbue(lc);
15117                            {
15118                                ios.width(0);
15119                                {
15120                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15121                                    std::string ex(str, iter.base());
15122                                    assert(ex == "-0.0");
15123                                    assert(ios.width() == 0);
15124                                }
15125                                ios.width(25);
15126                                left(ios);
15127                                {
15128                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15129                                    std::string ex(str, iter.base());
15130                                    assert(ex == "-0.0*********************");
15131                                    assert(ios.width() == 0);
15132                                }
15133                                ios.width(25);
15134                                right(ios);
15135                                {
15136                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15137                                    std::string ex(str, iter.base());
15138                                    assert(ex == "*********************-0.0");
15139                                    assert(ios.width() == 0);
15140                                }
15141                                ios.width(25);
15142                                internal(ios);
15143                                {
15144                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15145                                    std::string ex(str, iter.base());
15146                                    assert(ex == "-*********************0.0");
15147                                    assert(ios.width() == 0);
15148                                }
15149                            }
15150                            ios.imbue(lg);
15151                            {
15152                                ios.width(0);
15153                                {
15154                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15155                                    std::string ex(str, iter.base());
15156                                    assert(ex == "-0;0");
15157                                    assert(ios.width() == 0);
15158                                }
15159                                ios.width(25);
15160                                left(ios);
15161                                {
15162                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15163                                    std::string ex(str, iter.base());
15164                                    assert(ex == "-0;0*********************");
15165                                    assert(ios.width() == 0);
15166                                }
15167                                ios.width(25);
15168                                right(ios);
15169                                {
15170                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15171                                    std::string ex(str, iter.base());
15172                                    assert(ex == "*********************-0;0");
15173                                    assert(ios.width() == 0);
15174                                }
15175                                ios.width(25);
15176                                internal(ios);
15177                                {
15178                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15179                                    std::string ex(str, iter.base());
15180                                    assert(ex == "-*********************0;0");
15181                                    assert(ios.width() == 0);
15182                                }
15183                            }
15184                        }
15185                    }
15186                }
15187                uppercase(ios);
15188                {
15189                    noshowpos(ios);
15190                    {
15191                        noshowpoint(ios);
15192                        {
15193                            ios.imbue(lc);
15194                            {
15195                                ios.width(0);
15196                                {
15197                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15198                                    std::string ex(str, iter.base());
15199                                    assert(ex == "-0.0");
15200                                    assert(ios.width() == 0);
15201                                }
15202                                ios.width(25);
15203                                left(ios);
15204                                {
15205                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15206                                    std::string ex(str, iter.base());
15207                                    assert(ex == "-0.0*********************");
15208                                    assert(ios.width() == 0);
15209                                }
15210                                ios.width(25);
15211                                right(ios);
15212                                {
15213                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15214                                    std::string ex(str, iter.base());
15215                                    assert(ex == "*********************-0.0");
15216                                    assert(ios.width() == 0);
15217                                }
15218                                ios.width(25);
15219                                internal(ios);
15220                                {
15221                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15222                                    std::string ex(str, iter.base());
15223                                    assert(ex == "-*********************0.0");
15224                                    assert(ios.width() == 0);
15225                                }
15226                            }
15227                            ios.imbue(lg);
15228                            {
15229                                ios.width(0);
15230                                {
15231                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15232                                    std::string ex(str, iter.base());
15233                                    assert(ex == "-0;0");
15234                                    assert(ios.width() == 0);
15235                                }
15236                                ios.width(25);
15237                                left(ios);
15238                                {
15239                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15240                                    std::string ex(str, iter.base());
15241                                    assert(ex == "-0;0*********************");
15242                                    assert(ios.width() == 0);
15243                                }
15244                                ios.width(25);
15245                                right(ios);
15246                                {
15247                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15248                                    std::string ex(str, iter.base());
15249                                    assert(ex == "*********************-0;0");
15250                                    assert(ios.width() == 0);
15251                                }
15252                                ios.width(25);
15253                                internal(ios);
15254                                {
15255                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15256                                    std::string ex(str, iter.base());
15257                                    assert(ex == "-*********************0;0");
15258                                    assert(ios.width() == 0);
15259                                }
15260                            }
15261                        }
15262                        showpoint(ios);
15263                        {
15264                            ios.imbue(lc);
15265                            {
15266                                ios.width(0);
15267                                {
15268                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15269                                    std::string ex(str, iter.base());
15270                                    assert(ex == "-0.0");
15271                                    assert(ios.width() == 0);
15272                                }
15273                                ios.width(25);
15274                                left(ios);
15275                                {
15276                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15277                                    std::string ex(str, iter.base());
15278                                    assert(ex == "-0.0*********************");
15279                                    assert(ios.width() == 0);
15280                                }
15281                                ios.width(25);
15282                                right(ios);
15283                                {
15284                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15285                                    std::string ex(str, iter.base());
15286                                    assert(ex == "*********************-0.0");
15287                                    assert(ios.width() == 0);
15288                                }
15289                                ios.width(25);
15290                                internal(ios);
15291                                {
15292                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15293                                    std::string ex(str, iter.base());
15294                                    assert(ex == "-*********************0.0");
15295                                    assert(ios.width() == 0);
15296                                }
15297                            }
15298                            ios.imbue(lg);
15299                            {
15300                                ios.width(0);
15301                                {
15302                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15303                                    std::string ex(str, iter.base());
15304                                    assert(ex == "-0;0");
15305                                    assert(ios.width() == 0);
15306                                }
15307                                ios.width(25);
15308                                left(ios);
15309                                {
15310                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15311                                    std::string ex(str, iter.base());
15312                                    assert(ex == "-0;0*********************");
15313                                    assert(ios.width() == 0);
15314                                }
15315                                ios.width(25);
15316                                right(ios);
15317                                {
15318                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15319                                    std::string ex(str, iter.base());
15320                                    assert(ex == "*********************-0;0");
15321                                    assert(ios.width() == 0);
15322                                }
15323                                ios.width(25);
15324                                internal(ios);
15325                                {
15326                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15327                                    std::string ex(str, iter.base());
15328                                    assert(ex == "-*********************0;0");
15329                                    assert(ios.width() == 0);
15330                                }
15331                            }
15332                        }
15333                    }
15334                    showpos(ios);
15335                    {
15336                        noshowpoint(ios);
15337                        {
15338                            ios.imbue(lc);
15339                            {
15340                                ios.width(0);
15341                                {
15342                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15343                                    std::string ex(str, iter.base());
15344                                    assert(ex == "-0.0");
15345                                    assert(ios.width() == 0);
15346                                }
15347                                ios.width(25);
15348                                left(ios);
15349                                {
15350                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15351                                    std::string ex(str, iter.base());
15352                                    assert(ex == "-0.0*********************");
15353                                    assert(ios.width() == 0);
15354                                }
15355                                ios.width(25);
15356                                right(ios);
15357                                {
15358                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15359                                    std::string ex(str, iter.base());
15360                                    assert(ex == "*********************-0.0");
15361                                    assert(ios.width() == 0);
15362                                }
15363                                ios.width(25);
15364                                internal(ios);
15365                                {
15366                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15367                                    std::string ex(str, iter.base());
15368                                    assert(ex == "-*********************0.0");
15369                                    assert(ios.width() == 0);
15370                                }
15371                            }
15372                            ios.imbue(lg);
15373                            {
15374                                ios.width(0);
15375                                {
15376                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15377                                    std::string ex(str, iter.base());
15378                                    assert(ex == "-0;0");
15379                                    assert(ios.width() == 0);
15380                                }
15381                                ios.width(25);
15382                                left(ios);
15383                                {
15384                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15385                                    std::string ex(str, iter.base());
15386                                    assert(ex == "-0;0*********************");
15387                                    assert(ios.width() == 0);
15388                                }
15389                                ios.width(25);
15390                                right(ios);
15391                                {
15392                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15393                                    std::string ex(str, iter.base());
15394                                    assert(ex == "*********************-0;0");
15395                                    assert(ios.width() == 0);
15396                                }
15397                                ios.width(25);
15398                                internal(ios);
15399                                {
15400                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15401                                    std::string ex(str, iter.base());
15402                                    assert(ex == "-*********************0;0");
15403                                    assert(ios.width() == 0);
15404                                }
15405                            }
15406                        }
15407                        showpoint(ios);
15408                        {
15409                            ios.imbue(lc);
15410                            {
15411                                ios.width(0);
15412                                {
15413                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15414                                    std::string ex(str, iter.base());
15415                                    assert(ex == "-0.0");
15416                                    assert(ios.width() == 0);
15417                                }
15418                                ios.width(25);
15419                                left(ios);
15420                                {
15421                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15422                                    std::string ex(str, iter.base());
15423                                    assert(ex == "-0.0*********************");
15424                                    assert(ios.width() == 0);
15425                                }
15426                                ios.width(25);
15427                                right(ios);
15428                                {
15429                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15430                                    std::string ex(str, iter.base());
15431                                    assert(ex == "*********************-0.0");
15432                                    assert(ios.width() == 0);
15433                                }
15434                                ios.width(25);
15435                                internal(ios);
15436                                {
15437                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15438                                    std::string ex(str, iter.base());
15439                                    assert(ex == "-*********************0.0");
15440                                    assert(ios.width() == 0);
15441                                }
15442                            }
15443                            ios.imbue(lg);
15444                            {
15445                                ios.width(0);
15446                                {
15447                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15448                                    std::string ex(str, iter.base());
15449                                    assert(ex == "-0;0");
15450                                    assert(ios.width() == 0);
15451                                }
15452                                ios.width(25);
15453                                left(ios);
15454                                {
15455                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15456                                    std::string ex(str, iter.base());
15457                                    assert(ex == "-0;0*********************");
15458                                    assert(ios.width() == 0);
15459                                }
15460                                ios.width(25);
15461                                right(ios);
15462                                {
15463                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15464                                    std::string ex(str, iter.base());
15465                                    assert(ex == "*********************-0;0");
15466                                    assert(ios.width() == 0);
15467                                }
15468                                ios.width(25);
15469                                internal(ios);
15470                                {
15471                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15472                                    std::string ex(str, iter.base());
15473                                    assert(ex == "-*********************0;0");
15474                                    assert(ios.width() == 0);
15475                                }
15476                            }
15477                        }
15478                    }
15479                }
15480            }
15481            ios.precision(6);
15482            {
15483                nouppercase(ios);
15484                {
15485                    noshowpos(ios);
15486                    {
15487                        noshowpoint(ios);
15488                        {
15489                            ios.imbue(lc);
15490                            {
15491                                ios.width(0);
15492                                {
15493                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15494                                    std::string ex(str, iter.base());
15495                                    assert(ex == "-0.000000");
15496                                    assert(ios.width() == 0);
15497                                }
15498                                ios.width(25);
15499                                left(ios);
15500                                {
15501                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15502                                    std::string ex(str, iter.base());
15503                                    assert(ex == "-0.000000****************");
15504                                    assert(ios.width() == 0);
15505                                }
15506                                ios.width(25);
15507                                right(ios);
15508                                {
15509                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15510                                    std::string ex(str, iter.base());
15511                                    assert(ex == "****************-0.000000");
15512                                    assert(ios.width() == 0);
15513                                }
15514                                ios.width(25);
15515                                internal(ios);
15516                                {
15517                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15518                                    std::string ex(str, iter.base());
15519                                    assert(ex == "-****************0.000000");
15520                                    assert(ios.width() == 0);
15521                                }
15522                            }
15523                            ios.imbue(lg);
15524                            {
15525                                ios.width(0);
15526                                {
15527                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15528                                    std::string ex(str, iter.base());
15529                                    assert(ex == "-0;000000");
15530                                    assert(ios.width() == 0);
15531                                }
15532                                ios.width(25);
15533                                left(ios);
15534                                {
15535                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15536                                    std::string ex(str, iter.base());
15537                                    assert(ex == "-0;000000****************");
15538                                    assert(ios.width() == 0);
15539                                }
15540                                ios.width(25);
15541                                right(ios);
15542                                {
15543                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15544                                    std::string ex(str, iter.base());
15545                                    assert(ex == "****************-0;000000");
15546                                    assert(ios.width() == 0);
15547                                }
15548                                ios.width(25);
15549                                internal(ios);
15550                                {
15551                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15552                                    std::string ex(str, iter.base());
15553                                    assert(ex == "-****************0;000000");
15554                                    assert(ios.width() == 0);
15555                                }
15556                            }
15557                        }
15558                        showpoint(ios);
15559                        {
15560                            ios.imbue(lc);
15561                            {
15562                                ios.width(0);
15563                                {
15564                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15565                                    std::string ex(str, iter.base());
15566                                    assert(ex == "-0.000000");
15567                                    assert(ios.width() == 0);
15568                                }
15569                                ios.width(25);
15570                                left(ios);
15571                                {
15572                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15573                                    std::string ex(str, iter.base());
15574                                    assert(ex == "-0.000000****************");
15575                                    assert(ios.width() == 0);
15576                                }
15577                                ios.width(25);
15578                                right(ios);
15579                                {
15580                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15581                                    std::string ex(str, iter.base());
15582                                    assert(ex == "****************-0.000000");
15583                                    assert(ios.width() == 0);
15584                                }
15585                                ios.width(25);
15586                                internal(ios);
15587                                {
15588                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15589                                    std::string ex(str, iter.base());
15590                                    assert(ex == "-****************0.000000");
15591                                    assert(ios.width() == 0);
15592                                }
15593                            }
15594                            ios.imbue(lg);
15595                            {
15596                                ios.width(0);
15597                                {
15598                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15599                                    std::string ex(str, iter.base());
15600                                    assert(ex == "-0;000000");
15601                                    assert(ios.width() == 0);
15602                                }
15603                                ios.width(25);
15604                                left(ios);
15605                                {
15606                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15607                                    std::string ex(str, iter.base());
15608                                    assert(ex == "-0;000000****************");
15609                                    assert(ios.width() == 0);
15610                                }
15611                                ios.width(25);
15612                                right(ios);
15613                                {
15614                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15615                                    std::string ex(str, iter.base());
15616                                    assert(ex == "****************-0;000000");
15617                                    assert(ios.width() == 0);
15618                                }
15619                                ios.width(25);
15620                                internal(ios);
15621                                {
15622                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15623                                    std::string ex(str, iter.base());
15624                                    assert(ex == "-****************0;000000");
15625                                    assert(ios.width() == 0);
15626                                }
15627                            }
15628                        }
15629                    }
15630                    showpos(ios);
15631                    {
15632                        noshowpoint(ios);
15633                        {
15634                            ios.imbue(lc);
15635                            {
15636                                ios.width(0);
15637                                {
15638                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15639                                    std::string ex(str, iter.base());
15640                                    assert(ex == "-0.000000");
15641                                    assert(ios.width() == 0);
15642                                }
15643                                ios.width(25);
15644                                left(ios);
15645                                {
15646                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15647                                    std::string ex(str, iter.base());
15648                                    assert(ex == "-0.000000****************");
15649                                    assert(ios.width() == 0);
15650                                }
15651                                ios.width(25);
15652                                right(ios);
15653                                {
15654                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15655                                    std::string ex(str, iter.base());
15656                                    assert(ex == "****************-0.000000");
15657                                    assert(ios.width() == 0);
15658                                }
15659                                ios.width(25);
15660                                internal(ios);
15661                                {
15662                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15663                                    std::string ex(str, iter.base());
15664                                    assert(ex == "-****************0.000000");
15665                                    assert(ios.width() == 0);
15666                                }
15667                            }
15668                            ios.imbue(lg);
15669                            {
15670                                ios.width(0);
15671                                {
15672                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15673                                    std::string ex(str, iter.base());
15674                                    assert(ex == "-0;000000");
15675                                    assert(ios.width() == 0);
15676                                }
15677                                ios.width(25);
15678                                left(ios);
15679                                {
15680                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15681                                    std::string ex(str, iter.base());
15682                                    assert(ex == "-0;000000****************");
15683                                    assert(ios.width() == 0);
15684                                }
15685                                ios.width(25);
15686                                right(ios);
15687                                {
15688                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15689                                    std::string ex(str, iter.base());
15690                                    assert(ex == "****************-0;000000");
15691                                    assert(ios.width() == 0);
15692                                }
15693                                ios.width(25);
15694                                internal(ios);
15695                                {
15696                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15697                                    std::string ex(str, iter.base());
15698                                    assert(ex == "-****************0;000000");
15699                                    assert(ios.width() == 0);
15700                                }
15701                            }
15702                        }
15703                        showpoint(ios);
15704                        {
15705                            ios.imbue(lc);
15706                            {
15707                                ios.width(0);
15708                                {
15709                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15710                                    std::string ex(str, iter.base());
15711                                    assert(ex == "-0.000000");
15712                                    assert(ios.width() == 0);
15713                                }
15714                                ios.width(25);
15715                                left(ios);
15716                                {
15717                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15718                                    std::string ex(str, iter.base());
15719                                    assert(ex == "-0.000000****************");
15720                                    assert(ios.width() == 0);
15721                                }
15722                                ios.width(25);
15723                                right(ios);
15724                                {
15725                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15726                                    std::string ex(str, iter.base());
15727                                    assert(ex == "****************-0.000000");
15728                                    assert(ios.width() == 0);
15729                                }
15730                                ios.width(25);
15731                                internal(ios);
15732                                {
15733                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15734                                    std::string ex(str, iter.base());
15735                                    assert(ex == "-****************0.000000");
15736                                    assert(ios.width() == 0);
15737                                }
15738                            }
15739                            ios.imbue(lg);
15740                            {
15741                                ios.width(0);
15742                                {
15743                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15744                                    std::string ex(str, iter.base());
15745                                    assert(ex == "-0;000000");
15746                                    assert(ios.width() == 0);
15747                                }
15748                                ios.width(25);
15749                                left(ios);
15750                                {
15751                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15752                                    std::string ex(str, iter.base());
15753                                    assert(ex == "-0;000000****************");
15754                                    assert(ios.width() == 0);
15755                                }
15756                                ios.width(25);
15757                                right(ios);
15758                                {
15759                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15760                                    std::string ex(str, iter.base());
15761                                    assert(ex == "****************-0;000000");
15762                                    assert(ios.width() == 0);
15763                                }
15764                                ios.width(25);
15765                                internal(ios);
15766                                {
15767                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15768                                    std::string ex(str, iter.base());
15769                                    assert(ex == "-****************0;000000");
15770                                    assert(ios.width() == 0);
15771                                }
15772                            }
15773                        }
15774                    }
15775                }
15776                uppercase(ios);
15777                {
15778                    noshowpos(ios);
15779                    {
15780                        noshowpoint(ios);
15781                        {
15782                            ios.imbue(lc);
15783                            {
15784                                ios.width(0);
15785                                {
15786                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15787                                    std::string ex(str, iter.base());
15788                                    assert(ex == "-0.000000");
15789                                    assert(ios.width() == 0);
15790                                }
15791                                ios.width(25);
15792                                left(ios);
15793                                {
15794                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15795                                    std::string ex(str, iter.base());
15796                                    assert(ex == "-0.000000****************");
15797                                    assert(ios.width() == 0);
15798                                }
15799                                ios.width(25);
15800                                right(ios);
15801                                {
15802                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15803                                    std::string ex(str, iter.base());
15804                                    assert(ex == "****************-0.000000");
15805                                    assert(ios.width() == 0);
15806                                }
15807                                ios.width(25);
15808                                internal(ios);
15809                                {
15810                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15811                                    std::string ex(str, iter.base());
15812                                    assert(ex == "-****************0.000000");
15813                                    assert(ios.width() == 0);
15814                                }
15815                            }
15816                            ios.imbue(lg);
15817                            {
15818                                ios.width(0);
15819                                {
15820                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15821                                    std::string ex(str, iter.base());
15822                                    assert(ex == "-0;000000");
15823                                    assert(ios.width() == 0);
15824                                }
15825                                ios.width(25);
15826                                left(ios);
15827                                {
15828                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15829                                    std::string ex(str, iter.base());
15830                                    assert(ex == "-0;000000****************");
15831                                    assert(ios.width() == 0);
15832                                }
15833                                ios.width(25);
15834                                right(ios);
15835                                {
15836                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15837                                    std::string ex(str, iter.base());
15838                                    assert(ex == "****************-0;000000");
15839                                    assert(ios.width() == 0);
15840                                }
15841                                ios.width(25);
15842                                internal(ios);
15843                                {
15844                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15845                                    std::string ex(str, iter.base());
15846                                    assert(ex == "-****************0;000000");
15847                                    assert(ios.width() == 0);
15848                                }
15849                            }
15850                        }
15851                        showpoint(ios);
15852                        {
15853                            ios.imbue(lc);
15854                            {
15855                                ios.width(0);
15856                                {
15857                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15858                                    std::string ex(str, iter.base());
15859                                    assert(ex == "-0.000000");
15860                                    assert(ios.width() == 0);
15861                                }
15862                                ios.width(25);
15863                                left(ios);
15864                                {
15865                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15866                                    std::string ex(str, iter.base());
15867                                    assert(ex == "-0.000000****************");
15868                                    assert(ios.width() == 0);
15869                                }
15870                                ios.width(25);
15871                                right(ios);
15872                                {
15873                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15874                                    std::string ex(str, iter.base());
15875                                    assert(ex == "****************-0.000000");
15876                                    assert(ios.width() == 0);
15877                                }
15878                                ios.width(25);
15879                                internal(ios);
15880                                {
15881                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15882                                    std::string ex(str, iter.base());
15883                                    assert(ex == "-****************0.000000");
15884                                    assert(ios.width() == 0);
15885                                }
15886                            }
15887                            ios.imbue(lg);
15888                            {
15889                                ios.width(0);
15890                                {
15891                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15892                                    std::string ex(str, iter.base());
15893                                    assert(ex == "-0;000000");
15894                                    assert(ios.width() == 0);
15895                                }
15896                                ios.width(25);
15897                                left(ios);
15898                                {
15899                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15900                                    std::string ex(str, iter.base());
15901                                    assert(ex == "-0;000000****************");
15902                                    assert(ios.width() == 0);
15903                                }
15904                                ios.width(25);
15905                                right(ios);
15906                                {
15907                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15908                                    std::string ex(str, iter.base());
15909                                    assert(ex == "****************-0;000000");
15910                                    assert(ios.width() == 0);
15911                                }
15912                                ios.width(25);
15913                                internal(ios);
15914                                {
15915                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15916                                    std::string ex(str, iter.base());
15917                                    assert(ex == "-****************0;000000");
15918                                    assert(ios.width() == 0);
15919                                }
15920                            }
15921                        }
15922                    }
15923                    showpos(ios);
15924                    {
15925                        noshowpoint(ios);
15926                        {
15927                            ios.imbue(lc);
15928                            {
15929                                ios.width(0);
15930                                {
15931                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15932                                    std::string ex(str, iter.base());
15933                                    assert(ex == "-0.000000");
15934                                    assert(ios.width() == 0);
15935                                }
15936                                ios.width(25);
15937                                left(ios);
15938                                {
15939                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15940                                    std::string ex(str, iter.base());
15941                                    assert(ex == "-0.000000****************");
15942                                    assert(ios.width() == 0);
15943                                }
15944                                ios.width(25);
15945                                right(ios);
15946                                {
15947                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15948                                    std::string ex(str, iter.base());
15949                                    assert(ex == "****************-0.000000");
15950                                    assert(ios.width() == 0);
15951                                }
15952                                ios.width(25);
15953                                internal(ios);
15954                                {
15955                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15956                                    std::string ex(str, iter.base());
15957                                    assert(ex == "-****************0.000000");
15958                                    assert(ios.width() == 0);
15959                                }
15960                            }
15961                            ios.imbue(lg);
15962                            {
15963                                ios.width(0);
15964                                {
15965                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15966                                    std::string ex(str, iter.base());
15967                                    assert(ex == "-0;000000");
15968                                    assert(ios.width() == 0);
15969                                }
15970                                ios.width(25);
15971                                left(ios);
15972                                {
15973                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15974                                    std::string ex(str, iter.base());
15975                                    assert(ex == "-0;000000****************");
15976                                    assert(ios.width() == 0);
15977                                }
15978                                ios.width(25);
15979                                right(ios);
15980                                {
15981                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15982                                    std::string ex(str, iter.base());
15983                                    assert(ex == "****************-0;000000");
15984                                    assert(ios.width() == 0);
15985                                }
15986                                ios.width(25);
15987                                internal(ios);
15988                                {
15989                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
15990                                    std::string ex(str, iter.base());
15991                                    assert(ex == "-****************0;000000");
15992                                    assert(ios.width() == 0);
15993                                }
15994                            }
15995                        }
15996                        showpoint(ios);
15997                        {
15998                            ios.imbue(lc);
15999                            {
16000                                ios.width(0);
16001                                {
16002                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16003                                    std::string ex(str, iter.base());
16004                                    assert(ex == "-0.000000");
16005                                    assert(ios.width() == 0);
16006                                }
16007                                ios.width(25);
16008                                left(ios);
16009                                {
16010                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16011                                    std::string ex(str, iter.base());
16012                                    assert(ex == "-0.000000****************");
16013                                    assert(ios.width() == 0);
16014                                }
16015                                ios.width(25);
16016                                right(ios);
16017                                {
16018                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16019                                    std::string ex(str, iter.base());
16020                                    assert(ex == "****************-0.000000");
16021                                    assert(ios.width() == 0);
16022                                }
16023                                ios.width(25);
16024                                internal(ios);
16025                                {
16026                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16027                                    std::string ex(str, iter.base());
16028                                    assert(ex == "-****************0.000000");
16029                                    assert(ios.width() == 0);
16030                                }
16031                            }
16032                            ios.imbue(lg);
16033                            {
16034                                ios.width(0);
16035                                {
16036                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16037                                    std::string ex(str, iter.base());
16038                                    assert(ex == "-0;000000");
16039                                    assert(ios.width() == 0);
16040                                }
16041                                ios.width(25);
16042                                left(ios);
16043                                {
16044                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16045                                    std::string ex(str, iter.base());
16046                                    assert(ex == "-0;000000****************");
16047                                    assert(ios.width() == 0);
16048                                }
16049                                ios.width(25);
16050                                right(ios);
16051                                {
16052                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16053                                    std::string ex(str, iter.base());
16054                                    assert(ex == "****************-0;000000");
16055                                    assert(ios.width() == 0);
16056                                }
16057                                ios.width(25);
16058                                internal(ios);
16059                                {
16060                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16061                                    std::string ex(str, iter.base());
16062                                    assert(ex == "-****************0;000000");
16063                                    assert(ios.width() == 0);
16064                                }
16065                            }
16066                        }
16067                    }
16068                }
16069            }
16070            ios.precision(16);
16071            {
16072                nouppercase(ios);
16073                {
16074                    noshowpos(ios);
16075                    {
16076                        noshowpoint(ios);
16077                        {
16078                            ios.imbue(lc);
16079                            {
16080                                ios.width(0);
16081                                {
16082                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16083                                    std::string ex(str, iter.base());
16084                                    assert(ex == "-0.0000000000000000");
16085                                    assert(ios.width() == 0);
16086                                }
16087                                ios.width(25);
16088                                left(ios);
16089                                {
16090                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16091                                    std::string ex(str, iter.base());
16092                                    assert(ex == "-0.0000000000000000******");
16093                                    assert(ios.width() == 0);
16094                                }
16095                                ios.width(25);
16096                                right(ios);
16097                                {
16098                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16099                                    std::string ex(str, iter.base());
16100                                    assert(ex == "******-0.0000000000000000");
16101                                    assert(ios.width() == 0);
16102                                }
16103                                ios.width(25);
16104                                internal(ios);
16105                                {
16106                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16107                                    std::string ex(str, iter.base());
16108                                    assert(ex == "-******0.0000000000000000");
16109                                    assert(ios.width() == 0);
16110                                }
16111                            }
16112                            ios.imbue(lg);
16113                            {
16114                                ios.width(0);
16115                                {
16116                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16117                                    std::string ex(str, iter.base());
16118                                    assert(ex == "-0;0000000000000000");
16119                                    assert(ios.width() == 0);
16120                                }
16121                                ios.width(25);
16122                                left(ios);
16123                                {
16124                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16125                                    std::string ex(str, iter.base());
16126                                    assert(ex == "-0;0000000000000000******");
16127                                    assert(ios.width() == 0);
16128                                }
16129                                ios.width(25);
16130                                right(ios);
16131                                {
16132                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16133                                    std::string ex(str, iter.base());
16134                                    assert(ex == "******-0;0000000000000000");
16135                                    assert(ios.width() == 0);
16136                                }
16137                                ios.width(25);
16138                                internal(ios);
16139                                {
16140                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16141                                    std::string ex(str, iter.base());
16142                                    assert(ex == "-******0;0000000000000000");
16143                                    assert(ios.width() == 0);
16144                                }
16145                            }
16146                        }
16147                        showpoint(ios);
16148                        {
16149                            ios.imbue(lc);
16150                            {
16151                                ios.width(0);
16152                                {
16153                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16154                                    std::string ex(str, iter.base());
16155                                    assert(ex == "-0.0000000000000000");
16156                                    assert(ios.width() == 0);
16157                                }
16158                                ios.width(25);
16159                                left(ios);
16160                                {
16161                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16162                                    std::string ex(str, iter.base());
16163                                    assert(ex == "-0.0000000000000000******");
16164                                    assert(ios.width() == 0);
16165                                }
16166                                ios.width(25);
16167                                right(ios);
16168                                {
16169                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16170                                    std::string ex(str, iter.base());
16171                                    assert(ex == "******-0.0000000000000000");
16172                                    assert(ios.width() == 0);
16173                                }
16174                                ios.width(25);
16175                                internal(ios);
16176                                {
16177                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16178                                    std::string ex(str, iter.base());
16179                                    assert(ex == "-******0.0000000000000000");
16180                                    assert(ios.width() == 0);
16181                                }
16182                            }
16183                            ios.imbue(lg);
16184                            {
16185                                ios.width(0);
16186                                {
16187                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16188                                    std::string ex(str, iter.base());
16189                                    assert(ex == "-0;0000000000000000");
16190                                    assert(ios.width() == 0);
16191                                }
16192                                ios.width(25);
16193                                left(ios);
16194                                {
16195                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16196                                    std::string ex(str, iter.base());
16197                                    assert(ex == "-0;0000000000000000******");
16198                                    assert(ios.width() == 0);
16199                                }
16200                                ios.width(25);
16201                                right(ios);
16202                                {
16203                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16204                                    std::string ex(str, iter.base());
16205                                    assert(ex == "******-0;0000000000000000");
16206                                    assert(ios.width() == 0);
16207                                }
16208                                ios.width(25);
16209                                internal(ios);
16210                                {
16211                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16212                                    std::string ex(str, iter.base());
16213                                    assert(ex == "-******0;0000000000000000");
16214                                    assert(ios.width() == 0);
16215                                }
16216                            }
16217                        }
16218                    }
16219                    showpos(ios);
16220                    {
16221                        noshowpoint(ios);
16222                        {
16223                            ios.imbue(lc);
16224                            {
16225                                ios.width(0);
16226                                {
16227                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16228                                    std::string ex(str, iter.base());
16229                                    assert(ex == "-0.0000000000000000");
16230                                    assert(ios.width() == 0);
16231                                }
16232                                ios.width(25);
16233                                left(ios);
16234                                {
16235                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16236                                    std::string ex(str, iter.base());
16237                                    assert(ex == "-0.0000000000000000******");
16238                                    assert(ios.width() == 0);
16239                                }
16240                                ios.width(25);
16241                                right(ios);
16242                                {
16243                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16244                                    std::string ex(str, iter.base());
16245                                    assert(ex == "******-0.0000000000000000");
16246                                    assert(ios.width() == 0);
16247                                }
16248                                ios.width(25);
16249                                internal(ios);
16250                                {
16251                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16252                                    std::string ex(str, iter.base());
16253                                    assert(ex == "-******0.0000000000000000");
16254                                    assert(ios.width() == 0);
16255                                }
16256                            }
16257                            ios.imbue(lg);
16258                            {
16259                                ios.width(0);
16260                                {
16261                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16262                                    std::string ex(str, iter.base());
16263                                    assert(ex == "-0;0000000000000000");
16264                                    assert(ios.width() == 0);
16265                                }
16266                                ios.width(25);
16267                                left(ios);
16268                                {
16269                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16270                                    std::string ex(str, iter.base());
16271                                    assert(ex == "-0;0000000000000000******");
16272                                    assert(ios.width() == 0);
16273                                }
16274                                ios.width(25);
16275                                right(ios);
16276                                {
16277                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16278                                    std::string ex(str, iter.base());
16279                                    assert(ex == "******-0;0000000000000000");
16280                                    assert(ios.width() == 0);
16281                                }
16282                                ios.width(25);
16283                                internal(ios);
16284                                {
16285                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16286                                    std::string ex(str, iter.base());
16287                                    assert(ex == "-******0;0000000000000000");
16288                                    assert(ios.width() == 0);
16289                                }
16290                            }
16291                        }
16292                        showpoint(ios);
16293                        {
16294                            ios.imbue(lc);
16295                            {
16296                                ios.width(0);
16297                                {
16298                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16299                                    std::string ex(str, iter.base());
16300                                    assert(ex == "-0.0000000000000000");
16301                                    assert(ios.width() == 0);
16302                                }
16303                                ios.width(25);
16304                                left(ios);
16305                                {
16306                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16307                                    std::string ex(str, iter.base());
16308                                    assert(ex == "-0.0000000000000000******");
16309                                    assert(ios.width() == 0);
16310                                }
16311                                ios.width(25);
16312                                right(ios);
16313                                {
16314                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16315                                    std::string ex(str, iter.base());
16316                                    assert(ex == "******-0.0000000000000000");
16317                                    assert(ios.width() == 0);
16318                                }
16319                                ios.width(25);
16320                                internal(ios);
16321                                {
16322                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16323                                    std::string ex(str, iter.base());
16324                                    assert(ex == "-******0.0000000000000000");
16325                                    assert(ios.width() == 0);
16326                                }
16327                            }
16328                            ios.imbue(lg);
16329                            {
16330                                ios.width(0);
16331                                {
16332                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16333                                    std::string ex(str, iter.base());
16334                                    assert(ex == "-0;0000000000000000");
16335                                    assert(ios.width() == 0);
16336                                }
16337                                ios.width(25);
16338                                left(ios);
16339                                {
16340                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16341                                    std::string ex(str, iter.base());
16342                                    assert(ex == "-0;0000000000000000******");
16343                                    assert(ios.width() == 0);
16344                                }
16345                                ios.width(25);
16346                                right(ios);
16347                                {
16348                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16349                                    std::string ex(str, iter.base());
16350                                    assert(ex == "******-0;0000000000000000");
16351                                    assert(ios.width() == 0);
16352                                }
16353                                ios.width(25);
16354                                internal(ios);
16355                                {
16356                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16357                                    std::string ex(str, iter.base());
16358                                    assert(ex == "-******0;0000000000000000");
16359                                    assert(ios.width() == 0);
16360                                }
16361                            }
16362                        }
16363                    }
16364                }
16365                uppercase(ios);
16366                {
16367                    noshowpos(ios);
16368                    {
16369                        noshowpoint(ios);
16370                        {
16371                            ios.imbue(lc);
16372                            {
16373                                ios.width(0);
16374                                {
16375                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16376                                    std::string ex(str, iter.base());
16377                                    assert(ex == "-0.0000000000000000");
16378                                    assert(ios.width() == 0);
16379                                }
16380                                ios.width(25);
16381                                left(ios);
16382                                {
16383                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16384                                    std::string ex(str, iter.base());
16385                                    assert(ex == "-0.0000000000000000******");
16386                                    assert(ios.width() == 0);
16387                                }
16388                                ios.width(25);
16389                                right(ios);
16390                                {
16391                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16392                                    std::string ex(str, iter.base());
16393                                    assert(ex == "******-0.0000000000000000");
16394                                    assert(ios.width() == 0);
16395                                }
16396                                ios.width(25);
16397                                internal(ios);
16398                                {
16399                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16400                                    std::string ex(str, iter.base());
16401                                    assert(ex == "-******0.0000000000000000");
16402                                    assert(ios.width() == 0);
16403                                }
16404                            }
16405                            ios.imbue(lg);
16406                            {
16407                                ios.width(0);
16408                                {
16409                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16410                                    std::string ex(str, iter.base());
16411                                    assert(ex == "-0;0000000000000000");
16412                                    assert(ios.width() == 0);
16413                                }
16414                                ios.width(25);
16415                                left(ios);
16416                                {
16417                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16418                                    std::string ex(str, iter.base());
16419                                    assert(ex == "-0;0000000000000000******");
16420                                    assert(ios.width() == 0);
16421                                }
16422                                ios.width(25);
16423                                right(ios);
16424                                {
16425                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16426                                    std::string ex(str, iter.base());
16427                                    assert(ex == "******-0;0000000000000000");
16428                                    assert(ios.width() == 0);
16429                                }
16430                                ios.width(25);
16431                                internal(ios);
16432                                {
16433                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16434                                    std::string ex(str, iter.base());
16435                                    assert(ex == "-******0;0000000000000000");
16436                                    assert(ios.width() == 0);
16437                                }
16438                            }
16439                        }
16440                        showpoint(ios);
16441                        {
16442                            ios.imbue(lc);
16443                            {
16444                                ios.width(0);
16445                                {
16446                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16447                                    std::string ex(str, iter.base());
16448                                    assert(ex == "-0.0000000000000000");
16449                                    assert(ios.width() == 0);
16450                                }
16451                                ios.width(25);
16452                                left(ios);
16453                                {
16454                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16455                                    std::string ex(str, iter.base());
16456                                    assert(ex == "-0.0000000000000000******");
16457                                    assert(ios.width() == 0);
16458                                }
16459                                ios.width(25);
16460                                right(ios);
16461                                {
16462                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16463                                    std::string ex(str, iter.base());
16464                                    assert(ex == "******-0.0000000000000000");
16465                                    assert(ios.width() == 0);
16466                                }
16467                                ios.width(25);
16468                                internal(ios);
16469                                {
16470                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16471                                    std::string ex(str, iter.base());
16472                                    assert(ex == "-******0.0000000000000000");
16473                                    assert(ios.width() == 0);
16474                                }
16475                            }
16476                            ios.imbue(lg);
16477                            {
16478                                ios.width(0);
16479                                {
16480                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16481                                    std::string ex(str, iter.base());
16482                                    assert(ex == "-0;0000000000000000");
16483                                    assert(ios.width() == 0);
16484                                }
16485                                ios.width(25);
16486                                left(ios);
16487                                {
16488                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16489                                    std::string ex(str, iter.base());
16490                                    assert(ex == "-0;0000000000000000******");
16491                                    assert(ios.width() == 0);
16492                                }
16493                                ios.width(25);
16494                                right(ios);
16495                                {
16496                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16497                                    std::string ex(str, iter.base());
16498                                    assert(ex == "******-0;0000000000000000");
16499                                    assert(ios.width() == 0);
16500                                }
16501                                ios.width(25);
16502                                internal(ios);
16503                                {
16504                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16505                                    std::string ex(str, iter.base());
16506                                    assert(ex == "-******0;0000000000000000");
16507                                    assert(ios.width() == 0);
16508                                }
16509                            }
16510                        }
16511                    }
16512                    showpos(ios);
16513                    {
16514                        noshowpoint(ios);
16515                        {
16516                            ios.imbue(lc);
16517                            {
16518                                ios.width(0);
16519                                {
16520                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16521                                    std::string ex(str, iter.base());
16522                                    assert(ex == "-0.0000000000000000");
16523                                    assert(ios.width() == 0);
16524                                }
16525                                ios.width(25);
16526                                left(ios);
16527                                {
16528                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16529                                    std::string ex(str, iter.base());
16530                                    assert(ex == "-0.0000000000000000******");
16531                                    assert(ios.width() == 0);
16532                                }
16533                                ios.width(25);
16534                                right(ios);
16535                                {
16536                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16537                                    std::string ex(str, iter.base());
16538                                    assert(ex == "******-0.0000000000000000");
16539                                    assert(ios.width() == 0);
16540                                }
16541                                ios.width(25);
16542                                internal(ios);
16543                                {
16544                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16545                                    std::string ex(str, iter.base());
16546                                    assert(ex == "-******0.0000000000000000");
16547                                    assert(ios.width() == 0);
16548                                }
16549                            }
16550                            ios.imbue(lg);
16551                            {
16552                                ios.width(0);
16553                                {
16554                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16555                                    std::string ex(str, iter.base());
16556                                    assert(ex == "-0;0000000000000000");
16557                                    assert(ios.width() == 0);
16558                                }
16559                                ios.width(25);
16560                                left(ios);
16561                                {
16562                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16563                                    std::string ex(str, iter.base());
16564                                    assert(ex == "-0;0000000000000000******");
16565                                    assert(ios.width() == 0);
16566                                }
16567                                ios.width(25);
16568                                right(ios);
16569                                {
16570                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16571                                    std::string ex(str, iter.base());
16572                                    assert(ex == "******-0;0000000000000000");
16573                                    assert(ios.width() == 0);
16574                                }
16575                                ios.width(25);
16576                                internal(ios);
16577                                {
16578                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16579                                    std::string ex(str, iter.base());
16580                                    assert(ex == "-******0;0000000000000000");
16581                                    assert(ios.width() == 0);
16582                                }
16583                            }
16584                        }
16585                        showpoint(ios);
16586                        {
16587                            ios.imbue(lc);
16588                            {
16589                                ios.width(0);
16590                                {
16591                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16592                                    std::string ex(str, iter.base());
16593                                    assert(ex == "-0.0000000000000000");
16594                                    assert(ios.width() == 0);
16595                                }
16596                                ios.width(25);
16597                                left(ios);
16598                                {
16599                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16600                                    std::string ex(str, iter.base());
16601                                    assert(ex == "-0.0000000000000000******");
16602                                    assert(ios.width() == 0);
16603                                }
16604                                ios.width(25);
16605                                right(ios);
16606                                {
16607                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16608                                    std::string ex(str, iter.base());
16609                                    assert(ex == "******-0.0000000000000000");
16610                                    assert(ios.width() == 0);
16611                                }
16612                                ios.width(25);
16613                                internal(ios);
16614                                {
16615                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16616                                    std::string ex(str, iter.base());
16617                                    assert(ex == "-******0.0000000000000000");
16618                                    assert(ios.width() == 0);
16619                                }
16620                            }
16621                            ios.imbue(lg);
16622                            {
16623                                ios.width(0);
16624                                {
16625                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16626                                    std::string ex(str, iter.base());
16627                                    assert(ex == "-0;0000000000000000");
16628                                    assert(ios.width() == 0);
16629                                }
16630                                ios.width(25);
16631                                left(ios);
16632                                {
16633                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16634                                    std::string ex(str, iter.base());
16635                                    assert(ex == "-0;0000000000000000******");
16636                                    assert(ios.width() == 0);
16637                                }
16638                                ios.width(25);
16639                                right(ios);
16640                                {
16641                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16642                                    std::string ex(str, iter.base());
16643                                    assert(ex == "******-0;0000000000000000");
16644                                    assert(ios.width() == 0);
16645                                }
16646                                ios.width(25);
16647                                internal(ios);
16648                                {
16649                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16650                                    std::string ex(str, iter.base());
16651                                    assert(ex == "-******0;0000000000000000");
16652                                    assert(ios.width() == 0);
16653                                }
16654                            }
16655                        }
16656                    }
16657                }
16658            }
16659            ios.precision(60);
16660            {
16661                nouppercase(ios);
16662                {
16663                    noshowpos(ios);
16664                    {
16665                        noshowpoint(ios);
16666                        {
16667                            ios.imbue(lc);
16668                            {
16669                                ios.width(0);
16670                                {
16671                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16672                                    std::string ex(str, iter.base());
16673                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16674                                    assert(ios.width() == 0);
16675                                }
16676                                ios.width(25);
16677                                left(ios);
16678                                {
16679                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16680                                    std::string ex(str, iter.base());
16681                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16682                                    assert(ios.width() == 0);
16683                                }
16684                                ios.width(25);
16685                                right(ios);
16686                                {
16687                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16688                                    std::string ex(str, iter.base());
16689                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16690                                    assert(ios.width() == 0);
16691                                }
16692                                ios.width(25);
16693                                internal(ios);
16694                                {
16695                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16696                                    std::string ex(str, iter.base());
16697                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16698                                    assert(ios.width() == 0);
16699                                }
16700                            }
16701                            ios.imbue(lg);
16702                            {
16703                                ios.width(0);
16704                                {
16705                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16706                                    std::string ex(str, iter.base());
16707                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16708                                    assert(ios.width() == 0);
16709                                }
16710                                ios.width(25);
16711                                left(ios);
16712                                {
16713                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16714                                    std::string ex(str, iter.base());
16715                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16716                                    assert(ios.width() == 0);
16717                                }
16718                                ios.width(25);
16719                                right(ios);
16720                                {
16721                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16722                                    std::string ex(str, iter.base());
16723                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16724                                    assert(ios.width() == 0);
16725                                }
16726                                ios.width(25);
16727                                internal(ios);
16728                                {
16729                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16730                                    std::string ex(str, iter.base());
16731                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16732                                    assert(ios.width() == 0);
16733                                }
16734                            }
16735                        }
16736                        showpoint(ios);
16737                        {
16738                            ios.imbue(lc);
16739                            {
16740                                ios.width(0);
16741                                {
16742                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16743                                    std::string ex(str, iter.base());
16744                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16745                                    assert(ios.width() == 0);
16746                                }
16747                                ios.width(25);
16748                                left(ios);
16749                                {
16750                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16751                                    std::string ex(str, iter.base());
16752                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16753                                    assert(ios.width() == 0);
16754                                }
16755                                ios.width(25);
16756                                right(ios);
16757                                {
16758                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16759                                    std::string ex(str, iter.base());
16760                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16761                                    assert(ios.width() == 0);
16762                                }
16763                                ios.width(25);
16764                                internal(ios);
16765                                {
16766                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16767                                    std::string ex(str, iter.base());
16768                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16769                                    assert(ios.width() == 0);
16770                                }
16771                            }
16772                            ios.imbue(lg);
16773                            {
16774                                ios.width(0);
16775                                {
16776                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16777                                    std::string ex(str, iter.base());
16778                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16779                                    assert(ios.width() == 0);
16780                                }
16781                                ios.width(25);
16782                                left(ios);
16783                                {
16784                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16785                                    std::string ex(str, iter.base());
16786                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16787                                    assert(ios.width() == 0);
16788                                }
16789                                ios.width(25);
16790                                right(ios);
16791                                {
16792                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16793                                    std::string ex(str, iter.base());
16794                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16795                                    assert(ios.width() == 0);
16796                                }
16797                                ios.width(25);
16798                                internal(ios);
16799                                {
16800                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16801                                    std::string ex(str, iter.base());
16802                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16803                                    assert(ios.width() == 0);
16804                                }
16805                            }
16806                        }
16807                    }
16808                    showpos(ios);
16809                    {
16810                        noshowpoint(ios);
16811                        {
16812                            ios.imbue(lc);
16813                            {
16814                                ios.width(0);
16815                                {
16816                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16817                                    std::string ex(str, iter.base());
16818                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16819                                    assert(ios.width() == 0);
16820                                }
16821                                ios.width(25);
16822                                left(ios);
16823                                {
16824                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16825                                    std::string ex(str, iter.base());
16826                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16827                                    assert(ios.width() == 0);
16828                                }
16829                                ios.width(25);
16830                                right(ios);
16831                                {
16832                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16833                                    std::string ex(str, iter.base());
16834                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16835                                    assert(ios.width() == 0);
16836                                }
16837                                ios.width(25);
16838                                internal(ios);
16839                                {
16840                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16841                                    std::string ex(str, iter.base());
16842                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16843                                    assert(ios.width() == 0);
16844                                }
16845                            }
16846                            ios.imbue(lg);
16847                            {
16848                                ios.width(0);
16849                                {
16850                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16851                                    std::string ex(str, iter.base());
16852                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16853                                    assert(ios.width() == 0);
16854                                }
16855                                ios.width(25);
16856                                left(ios);
16857                                {
16858                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16859                                    std::string ex(str, iter.base());
16860                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16861                                    assert(ios.width() == 0);
16862                                }
16863                                ios.width(25);
16864                                right(ios);
16865                                {
16866                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16867                                    std::string ex(str, iter.base());
16868                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16869                                    assert(ios.width() == 0);
16870                                }
16871                                ios.width(25);
16872                                internal(ios);
16873                                {
16874                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16875                                    std::string ex(str, iter.base());
16876                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16877                                    assert(ios.width() == 0);
16878                                }
16879                            }
16880                        }
16881                        showpoint(ios);
16882                        {
16883                            ios.imbue(lc);
16884                            {
16885                                ios.width(0);
16886                                {
16887                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16888                                    std::string ex(str, iter.base());
16889                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16890                                    assert(ios.width() == 0);
16891                                }
16892                                ios.width(25);
16893                                left(ios);
16894                                {
16895                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16896                                    std::string ex(str, iter.base());
16897                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16898                                    assert(ios.width() == 0);
16899                                }
16900                                ios.width(25);
16901                                right(ios);
16902                                {
16903                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16904                                    std::string ex(str, iter.base());
16905                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16906                                    assert(ios.width() == 0);
16907                                }
16908                                ios.width(25);
16909                                internal(ios);
16910                                {
16911                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16912                                    std::string ex(str, iter.base());
16913                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16914                                    assert(ios.width() == 0);
16915                                }
16916                            }
16917                            ios.imbue(lg);
16918                            {
16919                                ios.width(0);
16920                                {
16921                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16922                                    std::string ex(str, iter.base());
16923                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16924                                    assert(ios.width() == 0);
16925                                }
16926                                ios.width(25);
16927                                left(ios);
16928                                {
16929                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16930                                    std::string ex(str, iter.base());
16931                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16932                                    assert(ios.width() == 0);
16933                                }
16934                                ios.width(25);
16935                                right(ios);
16936                                {
16937                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16938                                    std::string ex(str, iter.base());
16939                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16940                                    assert(ios.width() == 0);
16941                                }
16942                                ios.width(25);
16943                                internal(ios);
16944                                {
16945                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16946                                    std::string ex(str, iter.base());
16947                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
16948                                    assert(ios.width() == 0);
16949                                }
16950                            }
16951                        }
16952                    }
16953                }
16954                uppercase(ios);
16955                {
16956                    noshowpos(ios);
16957                    {
16958                        noshowpoint(ios);
16959                        {
16960                            ios.imbue(lc);
16961                            {
16962                                ios.width(0);
16963                                {
16964                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16965                                    std::string ex(str, iter.base());
16966                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16967                                    assert(ios.width() == 0);
16968                                }
16969                                ios.width(25);
16970                                left(ios);
16971                                {
16972                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16973                                    std::string ex(str, iter.base());
16974                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16975                                    assert(ios.width() == 0);
16976                                }
16977                                ios.width(25);
16978                                right(ios);
16979                                {
16980                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16981                                    std::string ex(str, iter.base());
16982                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16983                                    assert(ios.width() == 0);
16984                                }
16985                                ios.width(25);
16986                                internal(ios);
16987                                {
16988                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16989                                    std::string ex(str, iter.base());
16990                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
16991                                    assert(ios.width() == 0);
16992                                }
16993                            }
16994                            ios.imbue(lg);
16995                            {
16996                                ios.width(0);
16997                                {
16998                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
16999                                    std::string ex(str, iter.base());
17000                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17001                                    assert(ios.width() == 0);
17002                                }
17003                                ios.width(25);
17004                                left(ios);
17005                                {
17006                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17007                                    std::string ex(str, iter.base());
17008                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17009                                    assert(ios.width() == 0);
17010                                }
17011                                ios.width(25);
17012                                right(ios);
17013                                {
17014                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17015                                    std::string ex(str, iter.base());
17016                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17017                                    assert(ios.width() == 0);
17018                                }
17019                                ios.width(25);
17020                                internal(ios);
17021                                {
17022                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17023                                    std::string ex(str, iter.base());
17024                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17025                                    assert(ios.width() == 0);
17026                                }
17027                            }
17028                        }
17029                        showpoint(ios);
17030                        {
17031                            ios.imbue(lc);
17032                            {
17033                                ios.width(0);
17034                                {
17035                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17036                                    std::string ex(str, iter.base());
17037                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17038                                    assert(ios.width() == 0);
17039                                }
17040                                ios.width(25);
17041                                left(ios);
17042                                {
17043                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17044                                    std::string ex(str, iter.base());
17045                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17046                                    assert(ios.width() == 0);
17047                                }
17048                                ios.width(25);
17049                                right(ios);
17050                                {
17051                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17052                                    std::string ex(str, iter.base());
17053                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17054                                    assert(ios.width() == 0);
17055                                }
17056                                ios.width(25);
17057                                internal(ios);
17058                                {
17059                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17060                                    std::string ex(str, iter.base());
17061                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17062                                    assert(ios.width() == 0);
17063                                }
17064                            }
17065                            ios.imbue(lg);
17066                            {
17067                                ios.width(0);
17068                                {
17069                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17070                                    std::string ex(str, iter.base());
17071                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17072                                    assert(ios.width() == 0);
17073                                }
17074                                ios.width(25);
17075                                left(ios);
17076                                {
17077                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17078                                    std::string ex(str, iter.base());
17079                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17080                                    assert(ios.width() == 0);
17081                                }
17082                                ios.width(25);
17083                                right(ios);
17084                                {
17085                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17086                                    std::string ex(str, iter.base());
17087                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17088                                    assert(ios.width() == 0);
17089                                }
17090                                ios.width(25);
17091                                internal(ios);
17092                                {
17093                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17094                                    std::string ex(str, iter.base());
17095                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17096                                    assert(ios.width() == 0);
17097                                }
17098                            }
17099                        }
17100                    }
17101                    showpos(ios);
17102                    {
17103                        noshowpoint(ios);
17104                        {
17105                            ios.imbue(lc);
17106                            {
17107                                ios.width(0);
17108                                {
17109                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17110                                    std::string ex(str, iter.base());
17111                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17112                                    assert(ios.width() == 0);
17113                                }
17114                                ios.width(25);
17115                                left(ios);
17116                                {
17117                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17118                                    std::string ex(str, iter.base());
17119                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17120                                    assert(ios.width() == 0);
17121                                }
17122                                ios.width(25);
17123                                right(ios);
17124                                {
17125                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17126                                    std::string ex(str, iter.base());
17127                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17128                                    assert(ios.width() == 0);
17129                                }
17130                                ios.width(25);
17131                                internal(ios);
17132                                {
17133                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17134                                    std::string ex(str, iter.base());
17135                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17136                                    assert(ios.width() == 0);
17137                                }
17138                            }
17139                            ios.imbue(lg);
17140                            {
17141                                ios.width(0);
17142                                {
17143                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17144                                    std::string ex(str, iter.base());
17145                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17146                                    assert(ios.width() == 0);
17147                                }
17148                                ios.width(25);
17149                                left(ios);
17150                                {
17151                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17152                                    std::string ex(str, iter.base());
17153                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17154                                    assert(ios.width() == 0);
17155                                }
17156                                ios.width(25);
17157                                right(ios);
17158                                {
17159                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17160                                    std::string ex(str, iter.base());
17161                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17162                                    assert(ios.width() == 0);
17163                                }
17164                                ios.width(25);
17165                                internal(ios);
17166                                {
17167                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17168                                    std::string ex(str, iter.base());
17169                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17170                                    assert(ios.width() == 0);
17171                                }
17172                            }
17173                        }
17174                        showpoint(ios);
17175                        {
17176                            ios.imbue(lc);
17177                            {
17178                                ios.width(0);
17179                                {
17180                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17181                                    std::string ex(str, iter.base());
17182                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17183                                    assert(ios.width() == 0);
17184                                }
17185                                ios.width(25);
17186                                left(ios);
17187                                {
17188                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17189                                    std::string ex(str, iter.base());
17190                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17191                                    assert(ios.width() == 0);
17192                                }
17193                                ios.width(25);
17194                                right(ios);
17195                                {
17196                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17197                                    std::string ex(str, iter.base());
17198                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17199                                    assert(ios.width() == 0);
17200                                }
17201                                ios.width(25);
17202                                internal(ios);
17203                                {
17204                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17205                                    std::string ex(str, iter.base());
17206                                    assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
17207                                    assert(ios.width() == 0);
17208                                }
17209                            }
17210                            ios.imbue(lg);
17211                            {
17212                                ios.width(0);
17213                                {
17214                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17215                                    std::string ex(str, iter.base());
17216                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17217                                    assert(ios.width() == 0);
17218                                }
17219                                ios.width(25);
17220                                left(ios);
17221                                {
17222                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17223                                    std::string ex(str, iter.base());
17224                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17225                                    assert(ios.width() == 0);
17226                                }
17227                                ios.width(25);
17228                                right(ios);
17229                                {
17230                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17231                                    std::string ex(str, iter.base());
17232                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17233                                    assert(ios.width() == 0);
17234                                }
17235                                ios.width(25);
17236                                internal(ios);
17237                                {
17238                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17239                                    std::string ex(str, iter.base());
17240                                    assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
17241                                    assert(ios.width() == 0);
17242                                }
17243                            }
17244                        }
17245                    }
17246                }
17247            }
17248        }
17249    }
17250}
17251
17252void test8()
17253{
17254    char str[200];
17255    output_iterator<char*> iter;
17256    std::locale lc = std::locale::classic();
17257    std::locale lg(lc, new my_numpunct);
17258    const my_facet f(1);
17259    {
17260        long double v = 1234567890.125;
17261        std::ios ios(0);
17262        fixed(ios);
17263        // %f
17264        {
17265            ios.precision(0);
17266            {
17267                nouppercase(ios);
17268                {
17269                    noshowpos(ios);
17270                    {
17271                        noshowpoint(ios);
17272                        {
17273                            ios.imbue(lc);
17274                            {
17275                                ios.width(0);
17276                                {
17277                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17278                                    std::string ex(str, iter.base());
17279                                    assert(ex == "1234567890");
17280                                    assert(ios.width() == 0);
17281                                }
17282                                ios.width(25);
17283                                left(ios);
17284                                {
17285                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17286                                    std::string ex(str, iter.base());
17287                                    assert(ex == "1234567890***************");
17288                                    assert(ios.width() == 0);
17289                                }
17290                                ios.width(25);
17291                                right(ios);
17292                                {
17293                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17294                                    std::string ex(str, iter.base());
17295                                    assert(ex == "***************1234567890");
17296                                    assert(ios.width() == 0);
17297                                }
17298                                ios.width(25);
17299                                internal(ios);
17300                                {
17301                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17302                                    std::string ex(str, iter.base());
17303                                    assert(ex == "***************1234567890");
17304                                    assert(ios.width() == 0);
17305                                }
17306                            }
17307                            ios.imbue(lg);
17308                            {
17309                                ios.width(0);
17310                                {
17311                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17312                                    std::string ex(str, iter.base());
17313                                    assert(ex == "1_234_567_89_0");
17314                                    assert(ios.width() == 0);
17315                                }
17316                                ios.width(25);
17317                                left(ios);
17318                                {
17319                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17320                                    std::string ex(str, iter.base());
17321                                    assert(ex == "1_234_567_89_0***********");
17322                                    assert(ios.width() == 0);
17323                                }
17324                                ios.width(25);
17325                                right(ios);
17326                                {
17327                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17328                                    std::string ex(str, iter.base());
17329                                    assert(ex == "***********1_234_567_89_0");
17330                                    assert(ios.width() == 0);
17331                                }
17332                                ios.width(25);
17333                                internal(ios);
17334                                {
17335                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17336                                    std::string ex(str, iter.base());
17337                                    assert(ex == "***********1_234_567_89_0");
17338                                    assert(ios.width() == 0);
17339                                }
17340                            }
17341                        }
17342                        showpoint(ios);
17343                        {
17344                            ios.imbue(lc);
17345                            {
17346                                ios.width(0);
17347                                {
17348                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17349                                    std::string ex(str, iter.base());
17350                                    assert(ex == "1234567890.");
17351                                    assert(ios.width() == 0);
17352                                }
17353                                ios.width(25);
17354                                left(ios);
17355                                {
17356                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17357                                    std::string ex(str, iter.base());
17358                                    assert(ex == "1234567890.**************");
17359                                    assert(ios.width() == 0);
17360                                }
17361                                ios.width(25);
17362                                right(ios);
17363                                {
17364                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17365                                    std::string ex(str, iter.base());
17366                                    assert(ex == "**************1234567890.");
17367                                    assert(ios.width() == 0);
17368                                }
17369                                ios.width(25);
17370                                internal(ios);
17371                                {
17372                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17373                                    std::string ex(str, iter.base());
17374                                    assert(ex == "**************1234567890.");
17375                                    assert(ios.width() == 0);
17376                                }
17377                            }
17378                            ios.imbue(lg);
17379                            {
17380                                ios.width(0);
17381                                {
17382                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17383                                    std::string ex(str, iter.base());
17384                                    assert(ex == "1_234_567_89_0;");
17385                                    assert(ios.width() == 0);
17386                                }
17387                                ios.width(25);
17388                                left(ios);
17389                                {
17390                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17391                                    std::string ex(str, iter.base());
17392                                    assert(ex == "1_234_567_89_0;**********");
17393                                    assert(ios.width() == 0);
17394                                }
17395                                ios.width(25);
17396                                right(ios);
17397                                {
17398                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17399                                    std::string ex(str, iter.base());
17400                                    assert(ex == "**********1_234_567_89_0;");
17401                                    assert(ios.width() == 0);
17402                                }
17403                                ios.width(25);
17404                                internal(ios);
17405                                {
17406                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17407                                    std::string ex(str, iter.base());
17408                                    assert(ex == "**********1_234_567_89_0;");
17409                                    assert(ios.width() == 0);
17410                                }
17411                            }
17412                        }
17413                    }
17414                    showpos(ios);
17415                    {
17416                        noshowpoint(ios);
17417                        {
17418                            ios.imbue(lc);
17419                            {
17420                                ios.width(0);
17421                                {
17422                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17423                                    std::string ex(str, iter.base());
17424                                    assert(ex == "+1234567890");
17425                                    assert(ios.width() == 0);
17426                                }
17427                                ios.width(25);
17428                                left(ios);
17429                                {
17430                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17431                                    std::string ex(str, iter.base());
17432                                    assert(ex == "+1234567890**************");
17433                                    assert(ios.width() == 0);
17434                                }
17435                                ios.width(25);
17436                                right(ios);
17437                                {
17438                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17439                                    std::string ex(str, iter.base());
17440                                    assert(ex == "**************+1234567890");
17441                                    assert(ios.width() == 0);
17442                                }
17443                                ios.width(25);
17444                                internal(ios);
17445                                {
17446                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17447                                    std::string ex(str, iter.base());
17448                                    assert(ex == "+**************1234567890");
17449                                    assert(ios.width() == 0);
17450                                }
17451                            }
17452                            ios.imbue(lg);
17453                            {
17454                                ios.width(0);
17455                                {
17456                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17457                                    std::string ex(str, iter.base());
17458                                    assert(ex == "+1_234_567_89_0");
17459                                    assert(ios.width() == 0);
17460                                }
17461                                ios.width(25);
17462                                left(ios);
17463                                {
17464                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17465                                    std::string ex(str, iter.base());
17466                                    assert(ex == "+1_234_567_89_0**********");
17467                                    assert(ios.width() == 0);
17468                                }
17469                                ios.width(25);
17470                                right(ios);
17471                                {
17472                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17473                                    std::string ex(str, iter.base());
17474                                    assert(ex == "**********+1_234_567_89_0");
17475                                    assert(ios.width() == 0);
17476                                }
17477                                ios.width(25);
17478                                internal(ios);
17479                                {
17480                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17481                                    std::string ex(str, iter.base());
17482                                    assert(ex == "+**********1_234_567_89_0");
17483                                    assert(ios.width() == 0);
17484                                }
17485                            }
17486                        }
17487                        showpoint(ios);
17488                        {
17489                            ios.imbue(lc);
17490                            {
17491                                ios.width(0);
17492                                {
17493                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17494                                    std::string ex(str, iter.base());
17495                                    assert(ex == "+1234567890.");
17496                                    assert(ios.width() == 0);
17497                                }
17498                                ios.width(25);
17499                                left(ios);
17500                                {
17501                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17502                                    std::string ex(str, iter.base());
17503                                    assert(ex == "+1234567890.*************");
17504                                    assert(ios.width() == 0);
17505                                }
17506                                ios.width(25);
17507                                right(ios);
17508                                {
17509                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17510                                    std::string ex(str, iter.base());
17511                                    assert(ex == "*************+1234567890.");
17512                                    assert(ios.width() == 0);
17513                                }
17514                                ios.width(25);
17515                                internal(ios);
17516                                {
17517                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17518                                    std::string ex(str, iter.base());
17519                                    assert(ex == "+*************1234567890.");
17520                                    assert(ios.width() == 0);
17521                                }
17522                            }
17523                            ios.imbue(lg);
17524                            {
17525                                ios.width(0);
17526                                {
17527                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17528                                    std::string ex(str, iter.base());
17529                                    assert(ex == "+1_234_567_89_0;");
17530                                    assert(ios.width() == 0);
17531                                }
17532                                ios.width(25);
17533                                left(ios);
17534                                {
17535                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17536                                    std::string ex(str, iter.base());
17537                                    assert(ex == "+1_234_567_89_0;*********");
17538                                    assert(ios.width() == 0);
17539                                }
17540                                ios.width(25);
17541                                right(ios);
17542                                {
17543                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17544                                    std::string ex(str, iter.base());
17545                                    assert(ex == "*********+1_234_567_89_0;");
17546                                    assert(ios.width() == 0);
17547                                }
17548                                ios.width(25);
17549                                internal(ios);
17550                                {
17551                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17552                                    std::string ex(str, iter.base());
17553                                    assert(ex == "+*********1_234_567_89_0;");
17554                                    assert(ios.width() == 0);
17555                                }
17556                            }
17557                        }
17558                    }
17559                }
17560                uppercase(ios);
17561                {
17562                    noshowpos(ios);
17563                    {
17564                        noshowpoint(ios);
17565                        {
17566                            ios.imbue(lc);
17567                            {
17568                                ios.width(0);
17569                                {
17570                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17571                                    std::string ex(str, iter.base());
17572                                    assert(ex == "1234567890");
17573                                    assert(ios.width() == 0);
17574                                }
17575                                ios.width(25);
17576                                left(ios);
17577                                {
17578                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17579                                    std::string ex(str, iter.base());
17580                                    assert(ex == "1234567890***************");
17581                                    assert(ios.width() == 0);
17582                                }
17583                                ios.width(25);
17584                                right(ios);
17585                                {
17586                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17587                                    std::string ex(str, iter.base());
17588                                    assert(ex == "***************1234567890");
17589                                    assert(ios.width() == 0);
17590                                }
17591                                ios.width(25);
17592                                internal(ios);
17593                                {
17594                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17595                                    std::string ex(str, iter.base());
17596                                    assert(ex == "***************1234567890");
17597                                    assert(ios.width() == 0);
17598                                }
17599                            }
17600                            ios.imbue(lg);
17601                            {
17602                                ios.width(0);
17603                                {
17604                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17605                                    std::string ex(str, iter.base());
17606                                    assert(ex == "1_234_567_89_0");
17607                                    assert(ios.width() == 0);
17608                                }
17609                                ios.width(25);
17610                                left(ios);
17611                                {
17612                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17613                                    std::string ex(str, iter.base());
17614                                    assert(ex == "1_234_567_89_0***********");
17615                                    assert(ios.width() == 0);
17616                                }
17617                                ios.width(25);
17618                                right(ios);
17619                                {
17620                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17621                                    std::string ex(str, iter.base());
17622                                    assert(ex == "***********1_234_567_89_0");
17623                                    assert(ios.width() == 0);
17624                                }
17625                                ios.width(25);
17626                                internal(ios);
17627                                {
17628                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17629                                    std::string ex(str, iter.base());
17630                                    assert(ex == "***********1_234_567_89_0");
17631                                    assert(ios.width() == 0);
17632                                }
17633                            }
17634                        }
17635                        showpoint(ios);
17636                        {
17637                            ios.imbue(lc);
17638                            {
17639                                ios.width(0);
17640                                {
17641                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17642                                    std::string ex(str, iter.base());
17643                                    assert(ex == "1234567890.");
17644                                    assert(ios.width() == 0);
17645                                }
17646                                ios.width(25);
17647                                left(ios);
17648                                {
17649                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17650                                    std::string ex(str, iter.base());
17651                                    assert(ex == "1234567890.**************");
17652                                    assert(ios.width() == 0);
17653                                }
17654                                ios.width(25);
17655                                right(ios);
17656                                {
17657                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17658                                    std::string ex(str, iter.base());
17659                                    assert(ex == "**************1234567890.");
17660                                    assert(ios.width() == 0);
17661                                }
17662                                ios.width(25);
17663                                internal(ios);
17664                                {
17665                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17666                                    std::string ex(str, iter.base());
17667                                    assert(ex == "**************1234567890.");
17668                                    assert(ios.width() == 0);
17669                                }
17670                            }
17671                            ios.imbue(lg);
17672                            {
17673                                ios.width(0);
17674                                {
17675                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17676                                    std::string ex(str, iter.base());
17677                                    assert(ex == "1_234_567_89_0;");
17678                                    assert(ios.width() == 0);
17679                                }
17680                                ios.width(25);
17681                                left(ios);
17682                                {
17683                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17684                                    std::string ex(str, iter.base());
17685                                    assert(ex == "1_234_567_89_0;**********");
17686                                    assert(ios.width() == 0);
17687                                }
17688                                ios.width(25);
17689                                right(ios);
17690                                {
17691                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17692                                    std::string ex(str, iter.base());
17693                                    assert(ex == "**********1_234_567_89_0;");
17694                                    assert(ios.width() == 0);
17695                                }
17696                                ios.width(25);
17697                                internal(ios);
17698                                {
17699                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17700                                    std::string ex(str, iter.base());
17701                                    assert(ex == "**********1_234_567_89_0;");
17702                                    assert(ios.width() == 0);
17703                                }
17704                            }
17705                        }
17706                    }
17707                    showpos(ios);
17708                    {
17709                        noshowpoint(ios);
17710                        {
17711                            ios.imbue(lc);
17712                            {
17713                                ios.width(0);
17714                                {
17715                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17716                                    std::string ex(str, iter.base());
17717                                    assert(ex == "+1234567890");
17718                                    assert(ios.width() == 0);
17719                                }
17720                                ios.width(25);
17721                                left(ios);
17722                                {
17723                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17724                                    std::string ex(str, iter.base());
17725                                    assert(ex == "+1234567890**************");
17726                                    assert(ios.width() == 0);
17727                                }
17728                                ios.width(25);
17729                                right(ios);
17730                                {
17731                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17732                                    std::string ex(str, iter.base());
17733                                    assert(ex == "**************+1234567890");
17734                                    assert(ios.width() == 0);
17735                                }
17736                                ios.width(25);
17737                                internal(ios);
17738                                {
17739                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17740                                    std::string ex(str, iter.base());
17741                                    assert(ex == "+**************1234567890");
17742                                    assert(ios.width() == 0);
17743                                }
17744                            }
17745                            ios.imbue(lg);
17746                            {
17747                                ios.width(0);
17748                                {
17749                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17750                                    std::string ex(str, iter.base());
17751                                    assert(ex == "+1_234_567_89_0");
17752                                    assert(ios.width() == 0);
17753                                }
17754                                ios.width(25);
17755                                left(ios);
17756                                {
17757                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17758                                    std::string ex(str, iter.base());
17759                                    assert(ex == "+1_234_567_89_0**********");
17760                                    assert(ios.width() == 0);
17761                                }
17762                                ios.width(25);
17763                                right(ios);
17764                                {
17765                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17766                                    std::string ex(str, iter.base());
17767                                    assert(ex == "**********+1_234_567_89_0");
17768                                    assert(ios.width() == 0);
17769                                }
17770                                ios.width(25);
17771                                internal(ios);
17772                                {
17773                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17774                                    std::string ex(str, iter.base());
17775                                    assert(ex == "+**********1_234_567_89_0");
17776                                    assert(ios.width() == 0);
17777                                }
17778                            }
17779                        }
17780                        showpoint(ios);
17781                        {
17782                            ios.imbue(lc);
17783                            {
17784                                ios.width(0);
17785                                {
17786                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17787                                    std::string ex(str, iter.base());
17788                                    assert(ex == "+1234567890.");
17789                                    assert(ios.width() == 0);
17790                                }
17791                                ios.width(25);
17792                                left(ios);
17793                                {
17794                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17795                                    std::string ex(str, iter.base());
17796                                    assert(ex == "+1234567890.*************");
17797                                    assert(ios.width() == 0);
17798                                }
17799                                ios.width(25);
17800                                right(ios);
17801                                {
17802                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17803                                    std::string ex(str, iter.base());
17804                                    assert(ex == "*************+1234567890.");
17805                                    assert(ios.width() == 0);
17806                                }
17807                                ios.width(25);
17808                                internal(ios);
17809                                {
17810                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17811                                    std::string ex(str, iter.base());
17812                                    assert(ex == "+*************1234567890.");
17813                                    assert(ios.width() == 0);
17814                                }
17815                            }
17816                            ios.imbue(lg);
17817                            {
17818                                ios.width(0);
17819                                {
17820                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17821                                    std::string ex(str, iter.base());
17822                                    assert(ex == "+1_234_567_89_0;");
17823                                    assert(ios.width() == 0);
17824                                }
17825                                ios.width(25);
17826                                left(ios);
17827                                {
17828                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17829                                    std::string ex(str, iter.base());
17830                                    assert(ex == "+1_234_567_89_0;*********");
17831                                    assert(ios.width() == 0);
17832                                }
17833                                ios.width(25);
17834                                right(ios);
17835                                {
17836                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17837                                    std::string ex(str, iter.base());
17838                                    assert(ex == "*********+1_234_567_89_0;");
17839                                    assert(ios.width() == 0);
17840                                }
17841                                ios.width(25);
17842                                internal(ios);
17843                                {
17844                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17845                                    std::string ex(str, iter.base());
17846                                    assert(ex == "+*********1_234_567_89_0;");
17847                                    assert(ios.width() == 0);
17848                                }
17849                            }
17850                        }
17851                    }
17852                }
17853            }
17854            ios.precision(1);
17855            {
17856                nouppercase(ios);
17857                {
17858                    noshowpos(ios);
17859                    {
17860                        noshowpoint(ios);
17861                        {
17862                            ios.imbue(lc);
17863                            {
17864                                ios.width(0);
17865                                {
17866                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17867                                    std::string ex(str, iter.base());
17868                                    assert(ex == "1234567890.1");
17869                                    assert(ios.width() == 0);
17870                                }
17871                                ios.width(25);
17872                                left(ios);
17873                                {
17874                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17875                                    std::string ex(str, iter.base());
17876                                    assert(ex == "1234567890.1*************");
17877                                    assert(ios.width() == 0);
17878                                }
17879                                ios.width(25);
17880                                right(ios);
17881                                {
17882                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17883                                    std::string ex(str, iter.base());
17884                                    assert(ex == "*************1234567890.1");
17885                                    assert(ios.width() == 0);
17886                                }
17887                                ios.width(25);
17888                                internal(ios);
17889                                {
17890                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17891                                    std::string ex(str, iter.base());
17892                                    assert(ex == "*************1234567890.1");
17893                                    assert(ios.width() == 0);
17894                                }
17895                            }
17896                            ios.imbue(lg);
17897                            {
17898                                ios.width(0);
17899                                {
17900                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17901                                    std::string ex(str, iter.base());
17902                                    assert(ex == "1_234_567_89_0;1");
17903                                    assert(ios.width() == 0);
17904                                }
17905                                ios.width(25);
17906                                left(ios);
17907                                {
17908                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17909                                    std::string ex(str, iter.base());
17910                                    assert(ex == "1_234_567_89_0;1*********");
17911                                    assert(ios.width() == 0);
17912                                }
17913                                ios.width(25);
17914                                right(ios);
17915                                {
17916                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17917                                    std::string ex(str, iter.base());
17918                                    assert(ex == "*********1_234_567_89_0;1");
17919                                    assert(ios.width() == 0);
17920                                }
17921                                ios.width(25);
17922                                internal(ios);
17923                                {
17924                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17925                                    std::string ex(str, iter.base());
17926                                    assert(ex == "*********1_234_567_89_0;1");
17927                                    assert(ios.width() == 0);
17928                                }
17929                            }
17930                        }
17931                        showpoint(ios);
17932                        {
17933                            ios.imbue(lc);
17934                            {
17935                                ios.width(0);
17936                                {
17937                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17938                                    std::string ex(str, iter.base());
17939                                    assert(ex == "1234567890.1");
17940                                    assert(ios.width() == 0);
17941                                }
17942                                ios.width(25);
17943                                left(ios);
17944                                {
17945                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17946                                    std::string ex(str, iter.base());
17947                                    assert(ex == "1234567890.1*************");
17948                                    assert(ios.width() == 0);
17949                                }
17950                                ios.width(25);
17951                                right(ios);
17952                                {
17953                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17954                                    std::string ex(str, iter.base());
17955                                    assert(ex == "*************1234567890.1");
17956                                    assert(ios.width() == 0);
17957                                }
17958                                ios.width(25);
17959                                internal(ios);
17960                                {
17961                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17962                                    std::string ex(str, iter.base());
17963                                    assert(ex == "*************1234567890.1");
17964                                    assert(ios.width() == 0);
17965                                }
17966                            }
17967                            ios.imbue(lg);
17968                            {
17969                                ios.width(0);
17970                                {
17971                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17972                                    std::string ex(str, iter.base());
17973                                    assert(ex == "1_234_567_89_0;1");
17974                                    assert(ios.width() == 0);
17975                                }
17976                                ios.width(25);
17977                                left(ios);
17978                                {
17979                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17980                                    std::string ex(str, iter.base());
17981                                    assert(ex == "1_234_567_89_0;1*********");
17982                                    assert(ios.width() == 0);
17983                                }
17984                                ios.width(25);
17985                                right(ios);
17986                                {
17987                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17988                                    std::string ex(str, iter.base());
17989                                    assert(ex == "*********1_234_567_89_0;1");
17990                                    assert(ios.width() == 0);
17991                                }
17992                                ios.width(25);
17993                                internal(ios);
17994                                {
17995                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
17996                                    std::string ex(str, iter.base());
17997                                    assert(ex == "*********1_234_567_89_0;1");
17998                                    assert(ios.width() == 0);
17999                                }
18000                            }
18001                        }
18002                    }
18003                    showpos(ios);
18004                    {
18005                        noshowpoint(ios);
18006                        {
18007                            ios.imbue(lc);
18008                            {
18009                                ios.width(0);
18010                                {
18011                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18012                                    std::string ex(str, iter.base());
18013                                    assert(ex == "+1234567890.1");
18014                                    assert(ios.width() == 0);
18015                                }
18016                                ios.width(25);
18017                                left(ios);
18018                                {
18019                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18020                                    std::string ex(str, iter.base());
18021                                    assert(ex == "+1234567890.1************");
18022                                    assert(ios.width() == 0);
18023                                }
18024                                ios.width(25);
18025                                right(ios);
18026                                {
18027                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18028                                    std::string ex(str, iter.base());
18029                                    assert(ex == "************+1234567890.1");
18030                                    assert(ios.width() == 0);
18031                                }
18032                                ios.width(25);
18033                                internal(ios);
18034                                {
18035                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18036                                    std::string ex(str, iter.base());
18037                                    assert(ex == "+************1234567890.1");
18038                                    assert(ios.width() == 0);
18039                                }
18040                            }
18041                            ios.imbue(lg);
18042                            {
18043                                ios.width(0);
18044                                {
18045                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18046                                    std::string ex(str, iter.base());
18047                                    assert(ex == "+1_234_567_89_0;1");
18048                                    assert(ios.width() == 0);
18049                                }
18050                                ios.width(25);
18051                                left(ios);
18052                                {
18053                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18054                                    std::string ex(str, iter.base());
18055                                    assert(ex == "+1_234_567_89_0;1********");
18056                                    assert(ios.width() == 0);
18057                                }
18058                                ios.width(25);
18059                                right(ios);
18060                                {
18061                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18062                                    std::string ex(str, iter.base());
18063                                    assert(ex == "********+1_234_567_89_0;1");
18064                                    assert(ios.width() == 0);
18065                                }
18066                                ios.width(25);
18067                                internal(ios);
18068                                {
18069                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18070                                    std::string ex(str, iter.base());
18071                                    assert(ex == "+********1_234_567_89_0;1");
18072                                    assert(ios.width() == 0);
18073                                }
18074                            }
18075                        }
18076                        showpoint(ios);
18077                        {
18078                            ios.imbue(lc);
18079                            {
18080                                ios.width(0);
18081                                {
18082                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18083                                    std::string ex(str, iter.base());
18084                                    assert(ex == "+1234567890.1");
18085                                    assert(ios.width() == 0);
18086                                }
18087                                ios.width(25);
18088                                left(ios);
18089                                {
18090                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18091                                    std::string ex(str, iter.base());
18092                                    assert(ex == "+1234567890.1************");
18093                                    assert(ios.width() == 0);
18094                                }
18095                                ios.width(25);
18096                                right(ios);
18097                                {
18098                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18099                                    std::string ex(str, iter.base());
18100                                    assert(ex == "************+1234567890.1");
18101                                    assert(ios.width() == 0);
18102                                }
18103                                ios.width(25);
18104                                internal(ios);
18105                                {
18106                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18107                                    std::string ex(str, iter.base());
18108                                    assert(ex == "+************1234567890.1");
18109                                    assert(ios.width() == 0);
18110                                }
18111                            }
18112                            ios.imbue(lg);
18113                            {
18114                                ios.width(0);
18115                                {
18116                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18117                                    std::string ex(str, iter.base());
18118                                    assert(ex == "+1_234_567_89_0;1");
18119                                    assert(ios.width() == 0);
18120                                }
18121                                ios.width(25);
18122                                left(ios);
18123                                {
18124                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18125                                    std::string ex(str, iter.base());
18126                                    assert(ex == "+1_234_567_89_0;1********");
18127                                    assert(ios.width() == 0);
18128                                }
18129                                ios.width(25);
18130                                right(ios);
18131                                {
18132                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18133                                    std::string ex(str, iter.base());
18134                                    assert(ex == "********+1_234_567_89_0;1");
18135                                    assert(ios.width() == 0);
18136                                }
18137                                ios.width(25);
18138                                internal(ios);
18139                                {
18140                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18141                                    std::string ex(str, iter.base());
18142                                    assert(ex == "+********1_234_567_89_0;1");
18143                                    assert(ios.width() == 0);
18144                                }
18145                            }
18146                        }
18147                    }
18148                }
18149                uppercase(ios);
18150                {
18151                    noshowpos(ios);
18152                    {
18153                        noshowpoint(ios);
18154                        {
18155                            ios.imbue(lc);
18156                            {
18157                                ios.width(0);
18158                                {
18159                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18160                                    std::string ex(str, iter.base());
18161                                    assert(ex == "1234567890.1");
18162                                    assert(ios.width() == 0);
18163                                }
18164                                ios.width(25);
18165                                left(ios);
18166                                {
18167                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18168                                    std::string ex(str, iter.base());
18169                                    assert(ex == "1234567890.1*************");
18170                                    assert(ios.width() == 0);
18171                                }
18172                                ios.width(25);
18173                                right(ios);
18174                                {
18175                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18176                                    std::string ex(str, iter.base());
18177                                    assert(ex == "*************1234567890.1");
18178                                    assert(ios.width() == 0);
18179                                }
18180                                ios.width(25);
18181                                internal(ios);
18182                                {
18183                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18184                                    std::string ex(str, iter.base());
18185                                    assert(ex == "*************1234567890.1");
18186                                    assert(ios.width() == 0);
18187                                }
18188                            }
18189                            ios.imbue(lg);
18190                            {
18191                                ios.width(0);
18192                                {
18193                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18194                                    std::string ex(str, iter.base());
18195                                    assert(ex == "1_234_567_89_0;1");
18196                                    assert(ios.width() == 0);
18197                                }
18198                                ios.width(25);
18199                                left(ios);
18200                                {
18201                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18202                                    std::string ex(str, iter.base());
18203                                    assert(ex == "1_234_567_89_0;1*********");
18204                                    assert(ios.width() == 0);
18205                                }
18206                                ios.width(25);
18207                                right(ios);
18208                                {
18209                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18210                                    std::string ex(str, iter.base());
18211                                    assert(ex == "*********1_234_567_89_0;1");
18212                                    assert(ios.width() == 0);
18213                                }
18214                                ios.width(25);
18215                                internal(ios);
18216                                {
18217                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18218                                    std::string ex(str, iter.base());
18219                                    assert(ex == "*********1_234_567_89_0;1");
18220                                    assert(ios.width() == 0);
18221                                }
18222                            }
18223                        }
18224                        showpoint(ios);
18225                        {
18226                            ios.imbue(lc);
18227                            {
18228                                ios.width(0);
18229                                {
18230                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18231                                    std::string ex(str, iter.base());
18232                                    assert(ex == "1234567890.1");
18233                                    assert(ios.width() == 0);
18234                                }
18235                                ios.width(25);
18236                                left(ios);
18237                                {
18238                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18239                                    std::string ex(str, iter.base());
18240                                    assert(ex == "1234567890.1*************");
18241                                    assert(ios.width() == 0);
18242                                }
18243                                ios.width(25);
18244                                right(ios);
18245                                {
18246                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18247                                    std::string ex(str, iter.base());
18248                                    assert(ex == "*************1234567890.1");
18249                                    assert(ios.width() == 0);
18250                                }
18251                                ios.width(25);
18252                                internal(ios);
18253                                {
18254                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18255                                    std::string ex(str, iter.base());
18256                                    assert(ex == "*************1234567890.1");
18257                                    assert(ios.width() == 0);
18258                                }
18259                            }
18260                            ios.imbue(lg);
18261                            {
18262                                ios.width(0);
18263                                {
18264                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18265                                    std::string ex(str, iter.base());
18266                                    assert(ex == "1_234_567_89_0;1");
18267                                    assert(ios.width() == 0);
18268                                }
18269                                ios.width(25);
18270                                left(ios);
18271                                {
18272                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18273                                    std::string ex(str, iter.base());
18274                                    assert(ex == "1_234_567_89_0;1*********");
18275                                    assert(ios.width() == 0);
18276                                }
18277                                ios.width(25);
18278                                right(ios);
18279                                {
18280                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18281                                    std::string ex(str, iter.base());
18282                                    assert(ex == "*********1_234_567_89_0;1");
18283                                    assert(ios.width() == 0);
18284                                }
18285                                ios.width(25);
18286                                internal(ios);
18287                                {
18288                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18289                                    std::string ex(str, iter.base());
18290                                    assert(ex == "*********1_234_567_89_0;1");
18291                                    assert(ios.width() == 0);
18292                                }
18293                            }
18294                        }
18295                    }
18296                    showpos(ios);
18297                    {
18298                        noshowpoint(ios);
18299                        {
18300                            ios.imbue(lc);
18301                            {
18302                                ios.width(0);
18303                                {
18304                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18305                                    std::string ex(str, iter.base());
18306                                    assert(ex == "+1234567890.1");
18307                                    assert(ios.width() == 0);
18308                                }
18309                                ios.width(25);
18310                                left(ios);
18311                                {
18312                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18313                                    std::string ex(str, iter.base());
18314                                    assert(ex == "+1234567890.1************");
18315                                    assert(ios.width() == 0);
18316                                }
18317                                ios.width(25);
18318                                right(ios);
18319                                {
18320                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18321                                    std::string ex(str, iter.base());
18322                                    assert(ex == "************+1234567890.1");
18323                                    assert(ios.width() == 0);
18324                                }
18325                                ios.width(25);
18326                                internal(ios);
18327                                {
18328                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18329                                    std::string ex(str, iter.base());
18330                                    assert(ex == "+************1234567890.1");
18331                                    assert(ios.width() == 0);
18332                                }
18333                            }
18334                            ios.imbue(lg);
18335                            {
18336                                ios.width(0);
18337                                {
18338                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18339                                    std::string ex(str, iter.base());
18340                                    assert(ex == "+1_234_567_89_0;1");
18341                                    assert(ios.width() == 0);
18342                                }
18343                                ios.width(25);
18344                                left(ios);
18345                                {
18346                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18347                                    std::string ex(str, iter.base());
18348                                    assert(ex == "+1_234_567_89_0;1********");
18349                                    assert(ios.width() == 0);
18350                                }
18351                                ios.width(25);
18352                                right(ios);
18353                                {
18354                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18355                                    std::string ex(str, iter.base());
18356                                    assert(ex == "********+1_234_567_89_0;1");
18357                                    assert(ios.width() == 0);
18358                                }
18359                                ios.width(25);
18360                                internal(ios);
18361                                {
18362                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18363                                    std::string ex(str, iter.base());
18364                                    assert(ex == "+********1_234_567_89_0;1");
18365                                    assert(ios.width() == 0);
18366                                }
18367                            }
18368                        }
18369                        showpoint(ios);
18370                        {
18371                            ios.imbue(lc);
18372                            {
18373                                ios.width(0);
18374                                {
18375                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18376                                    std::string ex(str, iter.base());
18377                                    assert(ex == "+1234567890.1");
18378                                    assert(ios.width() == 0);
18379                                }
18380                                ios.width(25);
18381                                left(ios);
18382                                {
18383                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18384                                    std::string ex(str, iter.base());
18385                                    assert(ex == "+1234567890.1************");
18386                                    assert(ios.width() == 0);
18387                                }
18388                                ios.width(25);
18389                                right(ios);
18390                                {
18391                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18392                                    std::string ex(str, iter.base());
18393                                    assert(ex == "************+1234567890.1");
18394                                    assert(ios.width() == 0);
18395                                }
18396                                ios.width(25);
18397                                internal(ios);
18398                                {
18399                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18400                                    std::string ex(str, iter.base());
18401                                    assert(ex == "+************1234567890.1");
18402                                    assert(ios.width() == 0);
18403                                }
18404                            }
18405                            ios.imbue(lg);
18406                            {
18407                                ios.width(0);
18408                                {
18409                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18410                                    std::string ex(str, iter.base());
18411                                    assert(ex == "+1_234_567_89_0;1");
18412                                    assert(ios.width() == 0);
18413                                }
18414                                ios.width(25);
18415                                left(ios);
18416                                {
18417                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18418                                    std::string ex(str, iter.base());
18419                                    assert(ex == "+1_234_567_89_0;1********");
18420                                    assert(ios.width() == 0);
18421                                }
18422                                ios.width(25);
18423                                right(ios);
18424                                {
18425                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18426                                    std::string ex(str, iter.base());
18427                                    assert(ex == "********+1_234_567_89_0;1");
18428                                    assert(ios.width() == 0);
18429                                }
18430                                ios.width(25);
18431                                internal(ios);
18432                                {
18433                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18434                                    std::string ex(str, iter.base());
18435                                    assert(ex == "+********1_234_567_89_0;1");
18436                                    assert(ios.width() == 0);
18437                                }
18438                            }
18439                        }
18440                    }
18441                }
18442            }
18443            ios.precision(6);
18444            {
18445                nouppercase(ios);
18446                {
18447                    noshowpos(ios);
18448                    {
18449                        noshowpoint(ios);
18450                        {
18451                            ios.imbue(lc);
18452                            {
18453                                ios.width(0);
18454                                {
18455                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18456                                    std::string ex(str, iter.base());
18457                                    assert(ex == "1234567890.125000");
18458                                    assert(ios.width() == 0);
18459                                }
18460                                ios.width(25);
18461                                left(ios);
18462                                {
18463                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18464                                    std::string ex(str, iter.base());
18465                                    assert(ex == "1234567890.125000********");
18466                                    assert(ios.width() == 0);
18467                                }
18468                                ios.width(25);
18469                                right(ios);
18470                                {
18471                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18472                                    std::string ex(str, iter.base());
18473                                    assert(ex == "********1234567890.125000");
18474                                    assert(ios.width() == 0);
18475                                }
18476                                ios.width(25);
18477                                internal(ios);
18478                                {
18479                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18480                                    std::string ex(str, iter.base());
18481                                    assert(ex == "********1234567890.125000");
18482                                    assert(ios.width() == 0);
18483                                }
18484                            }
18485                            ios.imbue(lg);
18486                            {
18487                                ios.width(0);
18488                                {
18489                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18490                                    std::string ex(str, iter.base());
18491                                    assert(ex == "1_234_567_89_0;125000");
18492                                    assert(ios.width() == 0);
18493                                }
18494                                ios.width(25);
18495                                left(ios);
18496                                {
18497                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18498                                    std::string ex(str, iter.base());
18499                                    assert(ex == "1_234_567_89_0;125000****");
18500                                    assert(ios.width() == 0);
18501                                }
18502                                ios.width(25);
18503                                right(ios);
18504                                {
18505                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18506                                    std::string ex(str, iter.base());
18507                                    assert(ex == "****1_234_567_89_0;125000");
18508                                    assert(ios.width() == 0);
18509                                }
18510                                ios.width(25);
18511                                internal(ios);
18512                                {
18513                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18514                                    std::string ex(str, iter.base());
18515                                    assert(ex == "****1_234_567_89_0;125000");
18516                                    assert(ios.width() == 0);
18517                                }
18518                            }
18519                        }
18520                        showpoint(ios);
18521                        {
18522                            ios.imbue(lc);
18523                            {
18524                                ios.width(0);
18525                                {
18526                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18527                                    std::string ex(str, iter.base());
18528                                    assert(ex == "1234567890.125000");
18529                                    assert(ios.width() == 0);
18530                                }
18531                                ios.width(25);
18532                                left(ios);
18533                                {
18534                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18535                                    std::string ex(str, iter.base());
18536                                    assert(ex == "1234567890.125000********");
18537                                    assert(ios.width() == 0);
18538                                }
18539                                ios.width(25);
18540                                right(ios);
18541                                {
18542                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18543                                    std::string ex(str, iter.base());
18544                                    assert(ex == "********1234567890.125000");
18545                                    assert(ios.width() == 0);
18546                                }
18547                                ios.width(25);
18548                                internal(ios);
18549                                {
18550                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18551                                    std::string ex(str, iter.base());
18552                                    assert(ex == "********1234567890.125000");
18553                                    assert(ios.width() == 0);
18554                                }
18555                            }
18556                            ios.imbue(lg);
18557                            {
18558                                ios.width(0);
18559                                {
18560                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18561                                    std::string ex(str, iter.base());
18562                                    assert(ex == "1_234_567_89_0;125000");
18563                                    assert(ios.width() == 0);
18564                                }
18565                                ios.width(25);
18566                                left(ios);
18567                                {
18568                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18569                                    std::string ex(str, iter.base());
18570                                    assert(ex == "1_234_567_89_0;125000****");
18571                                    assert(ios.width() == 0);
18572                                }
18573                                ios.width(25);
18574                                right(ios);
18575                                {
18576                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18577                                    std::string ex(str, iter.base());
18578                                    assert(ex == "****1_234_567_89_0;125000");
18579                                    assert(ios.width() == 0);
18580                                }
18581                                ios.width(25);
18582                                internal(ios);
18583                                {
18584                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18585                                    std::string ex(str, iter.base());
18586                                    assert(ex == "****1_234_567_89_0;125000");
18587                                    assert(ios.width() == 0);
18588                                }
18589                            }
18590                        }
18591                    }
18592                    showpos(ios);
18593                    {
18594                        noshowpoint(ios);
18595                        {
18596                            ios.imbue(lc);
18597                            {
18598                                ios.width(0);
18599                                {
18600                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18601                                    std::string ex(str, iter.base());
18602                                    assert(ex == "+1234567890.125000");
18603                                    assert(ios.width() == 0);
18604                                }
18605                                ios.width(25);
18606                                left(ios);
18607                                {
18608                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18609                                    std::string ex(str, iter.base());
18610                                    assert(ex == "+1234567890.125000*******");
18611                                    assert(ios.width() == 0);
18612                                }
18613                                ios.width(25);
18614                                right(ios);
18615                                {
18616                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18617                                    std::string ex(str, iter.base());
18618                                    assert(ex == "*******+1234567890.125000");
18619                                    assert(ios.width() == 0);
18620                                }
18621                                ios.width(25);
18622                                internal(ios);
18623                                {
18624                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18625                                    std::string ex(str, iter.base());
18626                                    assert(ex == "+*******1234567890.125000");
18627                                    assert(ios.width() == 0);
18628                                }
18629                            }
18630                            ios.imbue(lg);
18631                            {
18632                                ios.width(0);
18633                                {
18634                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18635                                    std::string ex(str, iter.base());
18636                                    assert(ex == "+1_234_567_89_0;125000");
18637                                    assert(ios.width() == 0);
18638                                }
18639                                ios.width(25);
18640                                left(ios);
18641                                {
18642                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18643                                    std::string ex(str, iter.base());
18644                                    assert(ex == "+1_234_567_89_0;125000***");
18645                                    assert(ios.width() == 0);
18646                                }
18647                                ios.width(25);
18648                                right(ios);
18649                                {
18650                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18651                                    std::string ex(str, iter.base());
18652                                    assert(ex == "***+1_234_567_89_0;125000");
18653                                    assert(ios.width() == 0);
18654                                }
18655                                ios.width(25);
18656                                internal(ios);
18657                                {
18658                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18659                                    std::string ex(str, iter.base());
18660                                    assert(ex == "+***1_234_567_89_0;125000");
18661                                    assert(ios.width() == 0);
18662                                }
18663                            }
18664                        }
18665                        showpoint(ios);
18666                        {
18667                            ios.imbue(lc);
18668                            {
18669                                ios.width(0);
18670                                {
18671                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18672                                    std::string ex(str, iter.base());
18673                                    assert(ex == "+1234567890.125000");
18674                                    assert(ios.width() == 0);
18675                                }
18676                                ios.width(25);
18677                                left(ios);
18678                                {
18679                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18680                                    std::string ex(str, iter.base());
18681                                    assert(ex == "+1234567890.125000*******");
18682                                    assert(ios.width() == 0);
18683                                }
18684                                ios.width(25);
18685                                right(ios);
18686                                {
18687                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18688                                    std::string ex(str, iter.base());
18689                                    assert(ex == "*******+1234567890.125000");
18690                                    assert(ios.width() == 0);
18691                                }
18692                                ios.width(25);
18693                                internal(ios);
18694                                {
18695                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18696                                    std::string ex(str, iter.base());
18697                                    assert(ex == "+*******1234567890.125000");
18698                                    assert(ios.width() == 0);
18699                                }
18700                            }
18701                            ios.imbue(lg);
18702                            {
18703                                ios.width(0);
18704                                {
18705                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18706                                    std::string ex(str, iter.base());
18707                                    assert(ex == "+1_234_567_89_0;125000");
18708                                    assert(ios.width() == 0);
18709                                }
18710                                ios.width(25);
18711                                left(ios);
18712                                {
18713                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18714                                    std::string ex(str, iter.base());
18715                                    assert(ex == "+1_234_567_89_0;125000***");
18716                                    assert(ios.width() == 0);
18717                                }
18718                                ios.width(25);
18719                                right(ios);
18720                                {
18721                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18722                                    std::string ex(str, iter.base());
18723                                    assert(ex == "***+1_234_567_89_0;125000");
18724                                    assert(ios.width() == 0);
18725                                }
18726                                ios.width(25);
18727                                internal(ios);
18728                                {
18729                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18730                                    std::string ex(str, iter.base());
18731                                    assert(ex == "+***1_234_567_89_0;125000");
18732                                    assert(ios.width() == 0);
18733                                }
18734                            }
18735                        }
18736                    }
18737                }
18738                uppercase(ios);
18739                {
18740                    noshowpos(ios);
18741                    {
18742                        noshowpoint(ios);
18743                        {
18744                            ios.imbue(lc);
18745                            {
18746                                ios.width(0);
18747                                {
18748                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18749                                    std::string ex(str, iter.base());
18750                                    assert(ex == "1234567890.125000");
18751                                    assert(ios.width() == 0);
18752                                }
18753                                ios.width(25);
18754                                left(ios);
18755                                {
18756                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18757                                    std::string ex(str, iter.base());
18758                                    assert(ex == "1234567890.125000********");
18759                                    assert(ios.width() == 0);
18760                                }
18761                                ios.width(25);
18762                                right(ios);
18763                                {
18764                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18765                                    std::string ex(str, iter.base());
18766                                    assert(ex == "********1234567890.125000");
18767                                    assert(ios.width() == 0);
18768                                }
18769                                ios.width(25);
18770                                internal(ios);
18771                                {
18772                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18773                                    std::string ex(str, iter.base());
18774                                    assert(ex == "********1234567890.125000");
18775                                    assert(ios.width() == 0);
18776                                }
18777                            }
18778                            ios.imbue(lg);
18779                            {
18780                                ios.width(0);
18781                                {
18782                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18783                                    std::string ex(str, iter.base());
18784                                    assert(ex == "1_234_567_89_0;125000");
18785                                    assert(ios.width() == 0);
18786                                }
18787                                ios.width(25);
18788                                left(ios);
18789                                {
18790                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18791                                    std::string ex(str, iter.base());
18792                                    assert(ex == "1_234_567_89_0;125000****");
18793                                    assert(ios.width() == 0);
18794                                }
18795                                ios.width(25);
18796                                right(ios);
18797                                {
18798                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18799                                    std::string ex(str, iter.base());
18800                                    assert(ex == "****1_234_567_89_0;125000");
18801                                    assert(ios.width() == 0);
18802                                }
18803                                ios.width(25);
18804                                internal(ios);
18805                                {
18806                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18807                                    std::string ex(str, iter.base());
18808                                    assert(ex == "****1_234_567_89_0;125000");
18809                                    assert(ios.width() == 0);
18810                                }
18811                            }
18812                        }
18813                        showpoint(ios);
18814                        {
18815                            ios.imbue(lc);
18816                            {
18817                                ios.width(0);
18818                                {
18819                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18820                                    std::string ex(str, iter.base());
18821                                    assert(ex == "1234567890.125000");
18822                                    assert(ios.width() == 0);
18823                                }
18824                                ios.width(25);
18825                                left(ios);
18826                                {
18827                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18828                                    std::string ex(str, iter.base());
18829                                    assert(ex == "1234567890.125000********");
18830                                    assert(ios.width() == 0);
18831                                }
18832                                ios.width(25);
18833                                right(ios);
18834                                {
18835                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18836                                    std::string ex(str, iter.base());
18837                                    assert(ex == "********1234567890.125000");
18838                                    assert(ios.width() == 0);
18839                                }
18840                                ios.width(25);
18841                                internal(ios);
18842                                {
18843                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18844                                    std::string ex(str, iter.base());
18845                                    assert(ex == "********1234567890.125000");
18846                                    assert(ios.width() == 0);
18847                                }
18848                            }
18849                            ios.imbue(lg);
18850                            {
18851                                ios.width(0);
18852                                {
18853                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18854                                    std::string ex(str, iter.base());
18855                                    assert(ex == "1_234_567_89_0;125000");
18856                                    assert(ios.width() == 0);
18857                                }
18858                                ios.width(25);
18859                                left(ios);
18860                                {
18861                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18862                                    std::string ex(str, iter.base());
18863                                    assert(ex == "1_234_567_89_0;125000****");
18864                                    assert(ios.width() == 0);
18865                                }
18866                                ios.width(25);
18867                                right(ios);
18868                                {
18869                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18870                                    std::string ex(str, iter.base());
18871                                    assert(ex == "****1_234_567_89_0;125000");
18872                                    assert(ios.width() == 0);
18873                                }
18874                                ios.width(25);
18875                                internal(ios);
18876                                {
18877                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18878                                    std::string ex(str, iter.base());
18879                                    assert(ex == "****1_234_567_89_0;125000");
18880                                    assert(ios.width() == 0);
18881                                }
18882                            }
18883                        }
18884                    }
18885                    showpos(ios);
18886                    {
18887                        noshowpoint(ios);
18888                        {
18889                            ios.imbue(lc);
18890                            {
18891                                ios.width(0);
18892                                {
18893                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18894                                    std::string ex(str, iter.base());
18895                                    assert(ex == "+1234567890.125000");
18896                                    assert(ios.width() == 0);
18897                                }
18898                                ios.width(25);
18899                                left(ios);
18900                                {
18901                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18902                                    std::string ex(str, iter.base());
18903                                    assert(ex == "+1234567890.125000*******");
18904                                    assert(ios.width() == 0);
18905                                }
18906                                ios.width(25);
18907                                right(ios);
18908                                {
18909                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18910                                    std::string ex(str, iter.base());
18911                                    assert(ex == "*******+1234567890.125000");
18912                                    assert(ios.width() == 0);
18913                                }
18914                                ios.width(25);
18915                                internal(ios);
18916                                {
18917                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18918                                    std::string ex(str, iter.base());
18919                                    assert(ex == "+*******1234567890.125000");
18920                                    assert(ios.width() == 0);
18921                                }
18922                            }
18923                            ios.imbue(lg);
18924                            {
18925                                ios.width(0);
18926                                {
18927                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18928                                    std::string ex(str, iter.base());
18929                                    assert(ex == "+1_234_567_89_0;125000");
18930                                    assert(ios.width() == 0);
18931                                }
18932                                ios.width(25);
18933                                left(ios);
18934                                {
18935                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18936                                    std::string ex(str, iter.base());
18937                                    assert(ex == "+1_234_567_89_0;125000***");
18938                                    assert(ios.width() == 0);
18939                                }
18940                                ios.width(25);
18941                                right(ios);
18942                                {
18943                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18944                                    std::string ex(str, iter.base());
18945                                    assert(ex == "***+1_234_567_89_0;125000");
18946                                    assert(ios.width() == 0);
18947                                }
18948                                ios.width(25);
18949                                internal(ios);
18950                                {
18951                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18952                                    std::string ex(str, iter.base());
18953                                    assert(ex == "+***1_234_567_89_0;125000");
18954                                    assert(ios.width() == 0);
18955                                }
18956                            }
18957                        }
18958                        showpoint(ios);
18959                        {
18960                            ios.imbue(lc);
18961                            {
18962                                ios.width(0);
18963                                {
18964                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18965                                    std::string ex(str, iter.base());
18966                                    assert(ex == "+1234567890.125000");
18967                                    assert(ios.width() == 0);
18968                                }
18969                                ios.width(25);
18970                                left(ios);
18971                                {
18972                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18973                                    std::string ex(str, iter.base());
18974                                    assert(ex == "+1234567890.125000*******");
18975                                    assert(ios.width() == 0);
18976                                }
18977                                ios.width(25);
18978                                right(ios);
18979                                {
18980                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18981                                    std::string ex(str, iter.base());
18982                                    assert(ex == "*******+1234567890.125000");
18983                                    assert(ios.width() == 0);
18984                                }
18985                                ios.width(25);
18986                                internal(ios);
18987                                {
18988                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18989                                    std::string ex(str, iter.base());
18990                                    assert(ex == "+*******1234567890.125000");
18991                                    assert(ios.width() == 0);
18992                                }
18993                            }
18994                            ios.imbue(lg);
18995                            {
18996                                ios.width(0);
18997                                {
18998                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
18999                                    std::string ex(str, iter.base());
19000                                    assert(ex == "+1_234_567_89_0;125000");
19001                                    assert(ios.width() == 0);
19002                                }
19003                                ios.width(25);
19004                                left(ios);
19005                                {
19006                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19007                                    std::string ex(str, iter.base());
19008                                    assert(ex == "+1_234_567_89_0;125000***");
19009                                    assert(ios.width() == 0);
19010                                }
19011                                ios.width(25);
19012                                right(ios);
19013                                {
19014                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19015                                    std::string ex(str, iter.base());
19016                                    assert(ex == "***+1_234_567_89_0;125000");
19017                                    assert(ios.width() == 0);
19018                                }
19019                                ios.width(25);
19020                                internal(ios);
19021                                {
19022                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19023                                    std::string ex(str, iter.base());
19024                                    assert(ex == "+***1_234_567_89_0;125000");
19025                                    assert(ios.width() == 0);
19026                                }
19027                            }
19028                        }
19029                    }
19030                }
19031            }
19032            ios.precision(16);
19033            {}
19034            ios.precision(60);
19035            {}
19036        }
19037    }
19038}
19039
19040void test9()
19041{
19042    char str[200];
19043    output_iterator<char*> iter;
19044    std::locale lc = std::locale::classic();
19045    std::locale lg(lc, new my_numpunct);
19046    const my_facet f(1);
19047    {
19048        long double v = -0.;
19049        std::ios ios(0);
19050        scientific(ios);
19051        // %e
19052        {
19053            ios.precision(0);
19054            {
19055                nouppercase(ios);
19056                {
19057                    noshowpos(ios);
19058                    {
19059                        noshowpoint(ios);
19060                        {
19061                            ios.imbue(lc);
19062                            {
19063                                ios.width(0);
19064                                {
19065                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19066                                    std::string ex(str, iter.base());
19067                                    assert(ex == "-0e+00");
19068                                    assert(ios.width() == 0);
19069                                }
19070                                ios.width(25);
19071                                left(ios);
19072                                {
19073                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19074                                    std::string ex(str, iter.base());
19075                                    assert(ex == "-0e+00*******************");
19076                                    assert(ios.width() == 0);
19077                                }
19078                                ios.width(25);
19079                                right(ios);
19080                                {
19081                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19082                                    std::string ex(str, iter.base());
19083                                    assert(ex == "*******************-0e+00");
19084                                    assert(ios.width() == 0);
19085                                }
19086                                ios.width(25);
19087                                internal(ios);
19088                                {
19089                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19090                                    std::string ex(str, iter.base());
19091                                    assert(ex == "-*******************0e+00");
19092                                    assert(ios.width() == 0);
19093                                }
19094                            }
19095                            ios.imbue(lg);
19096                            {
19097                                ios.width(0);
19098                                {
19099                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19100                                    std::string ex(str, iter.base());
19101                                    assert(ex == "-0e+00");
19102                                    assert(ios.width() == 0);
19103                                }
19104                                ios.width(25);
19105                                left(ios);
19106                                {
19107                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19108                                    std::string ex(str, iter.base());
19109                                    assert(ex == "-0e+00*******************");
19110                                    assert(ios.width() == 0);
19111                                }
19112                                ios.width(25);
19113                                right(ios);
19114                                {
19115                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19116                                    std::string ex(str, iter.base());
19117                                    assert(ex == "*******************-0e+00");
19118                                    assert(ios.width() == 0);
19119                                }
19120                                ios.width(25);
19121                                internal(ios);
19122                                {
19123                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19124                                    std::string ex(str, iter.base());
19125                                    assert(ex == "-*******************0e+00");
19126                                    assert(ios.width() == 0);
19127                                }
19128                            }
19129                        }
19130                        showpoint(ios);
19131                        {
19132                            ios.imbue(lc);
19133                            {
19134                                ios.width(0);
19135                                {
19136                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19137                                    std::string ex(str, iter.base());
19138                                    assert(ex == "-0.e+00");
19139                                    assert(ios.width() == 0);
19140                                }
19141                                ios.width(25);
19142                                left(ios);
19143                                {
19144                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19145                                    std::string ex(str, iter.base());
19146                                    assert(ex == "-0.e+00******************");
19147                                    assert(ios.width() == 0);
19148                                }
19149                                ios.width(25);
19150                                right(ios);
19151                                {
19152                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19153                                    std::string ex(str, iter.base());
19154                                    assert(ex == "******************-0.e+00");
19155                                    assert(ios.width() == 0);
19156                                }
19157                                ios.width(25);
19158                                internal(ios);
19159                                {
19160                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19161                                    std::string ex(str, iter.base());
19162                                    assert(ex == "-******************0.e+00");
19163                                    assert(ios.width() == 0);
19164                                }
19165                            }
19166                            ios.imbue(lg);
19167                            {
19168                                ios.width(0);
19169                                {
19170                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19171                                    std::string ex(str, iter.base());
19172                                    assert(ex == "-0;e+00");
19173                                    assert(ios.width() == 0);
19174                                }
19175                                ios.width(25);
19176                                left(ios);
19177                                {
19178                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19179                                    std::string ex(str, iter.base());
19180                                    assert(ex == "-0;e+00******************");
19181                                    assert(ios.width() == 0);
19182                                }
19183                                ios.width(25);
19184                                right(ios);
19185                                {
19186                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19187                                    std::string ex(str, iter.base());
19188                                    assert(ex == "******************-0;e+00");
19189                                    assert(ios.width() == 0);
19190                                }
19191                                ios.width(25);
19192                                internal(ios);
19193                                {
19194                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19195                                    std::string ex(str, iter.base());
19196                                    assert(ex == "-******************0;e+00");
19197                                    assert(ios.width() == 0);
19198                                }
19199                            }
19200                        }
19201                    }
19202                    showpos(ios);
19203                    {
19204                        noshowpoint(ios);
19205                        {
19206                            ios.imbue(lc);
19207                            {
19208                                ios.width(0);
19209                                {
19210                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19211                                    std::string ex(str, iter.base());
19212                                    assert(ex == "-0e+00");
19213                                    assert(ios.width() == 0);
19214                                }
19215                                ios.width(25);
19216                                left(ios);
19217                                {
19218                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19219                                    std::string ex(str, iter.base());
19220                                    assert(ex == "-0e+00*******************");
19221                                    assert(ios.width() == 0);
19222                                }
19223                                ios.width(25);
19224                                right(ios);
19225                                {
19226                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19227                                    std::string ex(str, iter.base());
19228                                    assert(ex == "*******************-0e+00");
19229                                    assert(ios.width() == 0);
19230                                }
19231                                ios.width(25);
19232                                internal(ios);
19233                                {
19234                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19235                                    std::string ex(str, iter.base());
19236                                    assert(ex == "-*******************0e+00");
19237                                    assert(ios.width() == 0);
19238                                }
19239                            }
19240                            ios.imbue(lg);
19241                            {
19242                                ios.width(0);
19243                                {
19244                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19245                                    std::string ex(str, iter.base());
19246                                    assert(ex == "-0e+00");
19247                                    assert(ios.width() == 0);
19248                                }
19249                                ios.width(25);
19250                                left(ios);
19251                                {
19252                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19253                                    std::string ex(str, iter.base());
19254                                    assert(ex == "-0e+00*******************");
19255                                    assert(ios.width() == 0);
19256                                }
19257                                ios.width(25);
19258                                right(ios);
19259                                {
19260                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19261                                    std::string ex(str, iter.base());
19262                                    assert(ex == "*******************-0e+00");
19263                                    assert(ios.width() == 0);
19264                                }
19265                                ios.width(25);
19266                                internal(ios);
19267                                {
19268                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19269                                    std::string ex(str, iter.base());
19270                                    assert(ex == "-*******************0e+00");
19271                                    assert(ios.width() == 0);
19272                                }
19273                            }
19274                        }
19275                        showpoint(ios);
19276                        {
19277                            ios.imbue(lc);
19278                            {
19279                                ios.width(0);
19280                                {
19281                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19282                                    std::string ex(str, iter.base());
19283                                    assert(ex == "-0.e+00");
19284                                    assert(ios.width() == 0);
19285                                }
19286                                ios.width(25);
19287                                left(ios);
19288                                {
19289                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19290                                    std::string ex(str, iter.base());
19291                                    assert(ex == "-0.e+00******************");
19292                                    assert(ios.width() == 0);
19293                                }
19294                                ios.width(25);
19295                                right(ios);
19296                                {
19297                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19298                                    std::string ex(str, iter.base());
19299                                    assert(ex == "******************-0.e+00");
19300                                    assert(ios.width() == 0);
19301                                }
19302                                ios.width(25);
19303                                internal(ios);
19304                                {
19305                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19306                                    std::string ex(str, iter.base());
19307                                    assert(ex == "-******************0.e+00");
19308                                    assert(ios.width() == 0);
19309                                }
19310                            }
19311                            ios.imbue(lg);
19312                            {
19313                                ios.width(0);
19314                                {
19315                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19316                                    std::string ex(str, iter.base());
19317                                    assert(ex == "-0;e+00");
19318                                    assert(ios.width() == 0);
19319                                }
19320                                ios.width(25);
19321                                left(ios);
19322                                {
19323                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19324                                    std::string ex(str, iter.base());
19325                                    assert(ex == "-0;e+00******************");
19326                                    assert(ios.width() == 0);
19327                                }
19328                                ios.width(25);
19329                                right(ios);
19330                                {
19331                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19332                                    std::string ex(str, iter.base());
19333                                    assert(ex == "******************-0;e+00");
19334                                    assert(ios.width() == 0);
19335                                }
19336                                ios.width(25);
19337                                internal(ios);
19338                                {
19339                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19340                                    std::string ex(str, iter.base());
19341                                    assert(ex == "-******************0;e+00");
19342                                    assert(ios.width() == 0);
19343                                }
19344                            }
19345                        }
19346                    }
19347                }
19348                uppercase(ios);
19349                {
19350                    noshowpos(ios);
19351                    {
19352                        noshowpoint(ios);
19353                        {
19354                            ios.imbue(lc);
19355                            {
19356                                ios.width(0);
19357                                {
19358                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19359                                    std::string ex(str, iter.base());
19360                                    assert(ex == "-0E+00");
19361                                    assert(ios.width() == 0);
19362                                }
19363                                ios.width(25);
19364                                left(ios);
19365                                {
19366                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19367                                    std::string ex(str, iter.base());
19368                                    assert(ex == "-0E+00*******************");
19369                                    assert(ios.width() == 0);
19370                                }
19371                                ios.width(25);
19372                                right(ios);
19373                                {
19374                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19375                                    std::string ex(str, iter.base());
19376                                    assert(ex == "*******************-0E+00");
19377                                    assert(ios.width() == 0);
19378                                }
19379                                ios.width(25);
19380                                internal(ios);
19381                                {
19382                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19383                                    std::string ex(str, iter.base());
19384                                    assert(ex == "-*******************0E+00");
19385                                    assert(ios.width() == 0);
19386                                }
19387                            }
19388                            ios.imbue(lg);
19389                            {
19390                                ios.width(0);
19391                                {
19392                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19393                                    std::string ex(str, iter.base());
19394                                    assert(ex == "-0E+00");
19395                                    assert(ios.width() == 0);
19396                                }
19397                                ios.width(25);
19398                                left(ios);
19399                                {
19400                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19401                                    std::string ex(str, iter.base());
19402                                    assert(ex == "-0E+00*******************");
19403                                    assert(ios.width() == 0);
19404                                }
19405                                ios.width(25);
19406                                right(ios);
19407                                {
19408                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19409                                    std::string ex(str, iter.base());
19410                                    assert(ex == "*******************-0E+00");
19411                                    assert(ios.width() == 0);
19412                                }
19413                                ios.width(25);
19414                                internal(ios);
19415                                {
19416                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19417                                    std::string ex(str, iter.base());
19418                                    assert(ex == "-*******************0E+00");
19419                                    assert(ios.width() == 0);
19420                                }
19421                            }
19422                        }
19423                        showpoint(ios);
19424                        {
19425                            ios.imbue(lc);
19426                            {
19427                                ios.width(0);
19428                                {
19429                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19430                                    std::string ex(str, iter.base());
19431                                    assert(ex == "-0.E+00");
19432                                    assert(ios.width() == 0);
19433                                }
19434                                ios.width(25);
19435                                left(ios);
19436                                {
19437                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19438                                    std::string ex(str, iter.base());
19439                                    assert(ex == "-0.E+00******************");
19440                                    assert(ios.width() == 0);
19441                                }
19442                                ios.width(25);
19443                                right(ios);
19444                                {
19445                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19446                                    std::string ex(str, iter.base());
19447                                    assert(ex == "******************-0.E+00");
19448                                    assert(ios.width() == 0);
19449                                }
19450                                ios.width(25);
19451                                internal(ios);
19452                                {
19453                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19454                                    std::string ex(str, iter.base());
19455                                    assert(ex == "-******************0.E+00");
19456                                    assert(ios.width() == 0);
19457                                }
19458                            }
19459                            ios.imbue(lg);
19460                            {
19461                                ios.width(0);
19462                                {
19463                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19464                                    std::string ex(str, iter.base());
19465                                    assert(ex == "-0;E+00");
19466                                    assert(ios.width() == 0);
19467                                }
19468                                ios.width(25);
19469                                left(ios);
19470                                {
19471                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19472                                    std::string ex(str, iter.base());
19473                                    assert(ex == "-0;E+00******************");
19474                                    assert(ios.width() == 0);
19475                                }
19476                                ios.width(25);
19477                                right(ios);
19478                                {
19479                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19480                                    std::string ex(str, iter.base());
19481                                    assert(ex == "******************-0;E+00");
19482                                    assert(ios.width() == 0);
19483                                }
19484                                ios.width(25);
19485                                internal(ios);
19486                                {
19487                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19488                                    std::string ex(str, iter.base());
19489                                    assert(ex == "-******************0;E+00");
19490                                    assert(ios.width() == 0);
19491                                }
19492                            }
19493                        }
19494                    }
19495                    showpos(ios);
19496                    {
19497                        noshowpoint(ios);
19498                        {
19499                            ios.imbue(lc);
19500                            {
19501                                ios.width(0);
19502                                {
19503                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19504                                    std::string ex(str, iter.base());
19505                                    assert(ex == "-0E+00");
19506                                    assert(ios.width() == 0);
19507                                }
19508                                ios.width(25);
19509                                left(ios);
19510                                {
19511                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19512                                    std::string ex(str, iter.base());
19513                                    assert(ex == "-0E+00*******************");
19514                                    assert(ios.width() == 0);
19515                                }
19516                                ios.width(25);
19517                                right(ios);
19518                                {
19519                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19520                                    std::string ex(str, iter.base());
19521                                    assert(ex == "*******************-0E+00");
19522                                    assert(ios.width() == 0);
19523                                }
19524                                ios.width(25);
19525                                internal(ios);
19526                                {
19527                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19528                                    std::string ex(str, iter.base());
19529                                    assert(ex == "-*******************0E+00");
19530                                    assert(ios.width() == 0);
19531                                }
19532                            }
19533                            ios.imbue(lg);
19534                            {
19535                                ios.width(0);
19536                                {
19537                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19538                                    std::string ex(str, iter.base());
19539                                    assert(ex == "-0E+00");
19540                                    assert(ios.width() == 0);
19541                                }
19542                                ios.width(25);
19543                                left(ios);
19544                                {
19545                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19546                                    std::string ex(str, iter.base());
19547                                    assert(ex == "-0E+00*******************");
19548                                    assert(ios.width() == 0);
19549                                }
19550                                ios.width(25);
19551                                right(ios);
19552                                {
19553                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19554                                    std::string ex(str, iter.base());
19555                                    assert(ex == "*******************-0E+00");
19556                                    assert(ios.width() == 0);
19557                                }
19558                                ios.width(25);
19559                                internal(ios);
19560                                {
19561                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19562                                    std::string ex(str, iter.base());
19563                                    assert(ex == "-*******************0E+00");
19564                                    assert(ios.width() == 0);
19565                                }
19566                            }
19567                        }
19568                        showpoint(ios);
19569                        {
19570                            ios.imbue(lc);
19571                            {
19572                                ios.width(0);
19573                                {
19574                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19575                                    std::string ex(str, iter.base());
19576                                    assert(ex == "-0.E+00");
19577                                    assert(ios.width() == 0);
19578                                }
19579                                ios.width(25);
19580                                left(ios);
19581                                {
19582                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19583                                    std::string ex(str, iter.base());
19584                                    assert(ex == "-0.E+00******************");
19585                                    assert(ios.width() == 0);
19586                                }
19587                                ios.width(25);
19588                                right(ios);
19589                                {
19590                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19591                                    std::string ex(str, iter.base());
19592                                    assert(ex == "******************-0.E+00");
19593                                    assert(ios.width() == 0);
19594                                }
19595                                ios.width(25);
19596                                internal(ios);
19597                                {
19598                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19599                                    std::string ex(str, iter.base());
19600                                    assert(ex == "-******************0.E+00");
19601                                    assert(ios.width() == 0);
19602                                }
19603                            }
19604                            ios.imbue(lg);
19605                            {
19606                                ios.width(0);
19607                                {
19608                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19609                                    std::string ex(str, iter.base());
19610                                    assert(ex == "-0;E+00");
19611                                    assert(ios.width() == 0);
19612                                }
19613                                ios.width(25);
19614                                left(ios);
19615                                {
19616                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19617                                    std::string ex(str, iter.base());
19618                                    assert(ex == "-0;E+00******************");
19619                                    assert(ios.width() == 0);
19620                                }
19621                                ios.width(25);
19622                                right(ios);
19623                                {
19624                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19625                                    std::string ex(str, iter.base());
19626                                    assert(ex == "******************-0;E+00");
19627                                    assert(ios.width() == 0);
19628                                }
19629                                ios.width(25);
19630                                internal(ios);
19631                                {
19632                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19633                                    std::string ex(str, iter.base());
19634                                    assert(ex == "-******************0;E+00");
19635                                    assert(ios.width() == 0);
19636                                }
19637                            }
19638                        }
19639                    }
19640                }
19641            }
19642            ios.precision(1);
19643            {
19644                nouppercase(ios);
19645                {
19646                    noshowpos(ios);
19647                    {
19648                        noshowpoint(ios);
19649                        {
19650                            ios.imbue(lc);
19651                            {
19652                                ios.width(0);
19653                                {
19654                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19655                                    std::string ex(str, iter.base());
19656                                    assert(ex == "-0.0e+00");
19657                                    assert(ios.width() == 0);
19658                                }
19659                                ios.width(25);
19660                                left(ios);
19661                                {
19662                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19663                                    std::string ex(str, iter.base());
19664                                    assert(ex == "-0.0e+00*****************");
19665                                    assert(ios.width() == 0);
19666                                }
19667                                ios.width(25);
19668                                right(ios);
19669                                {
19670                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19671                                    std::string ex(str, iter.base());
19672                                    assert(ex == "*****************-0.0e+00");
19673                                    assert(ios.width() == 0);
19674                                }
19675                                ios.width(25);
19676                                internal(ios);
19677                                {
19678                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19679                                    std::string ex(str, iter.base());
19680                                    assert(ex == "-*****************0.0e+00");
19681                                    assert(ios.width() == 0);
19682                                }
19683                            }
19684                            ios.imbue(lg);
19685                            {
19686                                ios.width(0);
19687                                {
19688                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19689                                    std::string ex(str, iter.base());
19690                                    assert(ex == "-0;0e+00");
19691                                    assert(ios.width() == 0);
19692                                }
19693                                ios.width(25);
19694                                left(ios);
19695                                {
19696                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19697                                    std::string ex(str, iter.base());
19698                                    assert(ex == "-0;0e+00*****************");
19699                                    assert(ios.width() == 0);
19700                                }
19701                                ios.width(25);
19702                                right(ios);
19703                                {
19704                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19705                                    std::string ex(str, iter.base());
19706                                    assert(ex == "*****************-0;0e+00");
19707                                    assert(ios.width() == 0);
19708                                }
19709                                ios.width(25);
19710                                internal(ios);
19711                                {
19712                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19713                                    std::string ex(str, iter.base());
19714                                    assert(ex == "-*****************0;0e+00");
19715                                    assert(ios.width() == 0);
19716                                }
19717                            }
19718                        }
19719                        showpoint(ios);
19720                        {
19721                            ios.imbue(lc);
19722                            {
19723                                ios.width(0);
19724                                {
19725                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19726                                    std::string ex(str, iter.base());
19727                                    assert(ex == "-0.0e+00");
19728                                    assert(ios.width() == 0);
19729                                }
19730                                ios.width(25);
19731                                left(ios);
19732                                {
19733                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19734                                    std::string ex(str, iter.base());
19735                                    assert(ex == "-0.0e+00*****************");
19736                                    assert(ios.width() == 0);
19737                                }
19738                                ios.width(25);
19739                                right(ios);
19740                                {
19741                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19742                                    std::string ex(str, iter.base());
19743                                    assert(ex == "*****************-0.0e+00");
19744                                    assert(ios.width() == 0);
19745                                }
19746                                ios.width(25);
19747                                internal(ios);
19748                                {
19749                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19750                                    std::string ex(str, iter.base());
19751                                    assert(ex == "-*****************0.0e+00");
19752                                    assert(ios.width() == 0);
19753                                }
19754                            }
19755                            ios.imbue(lg);
19756                            {
19757                                ios.width(0);
19758                                {
19759                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19760                                    std::string ex(str, iter.base());
19761                                    assert(ex == "-0;0e+00");
19762                                    assert(ios.width() == 0);
19763                                }
19764                                ios.width(25);
19765                                left(ios);
19766                                {
19767                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19768                                    std::string ex(str, iter.base());
19769                                    assert(ex == "-0;0e+00*****************");
19770                                    assert(ios.width() == 0);
19771                                }
19772                                ios.width(25);
19773                                right(ios);
19774                                {
19775                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19776                                    std::string ex(str, iter.base());
19777                                    assert(ex == "*****************-0;0e+00");
19778                                    assert(ios.width() == 0);
19779                                }
19780                                ios.width(25);
19781                                internal(ios);
19782                                {
19783                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19784                                    std::string ex(str, iter.base());
19785                                    assert(ex == "-*****************0;0e+00");
19786                                    assert(ios.width() == 0);
19787                                }
19788                            }
19789                        }
19790                    }
19791                    showpos(ios);
19792                    {
19793                        noshowpoint(ios);
19794                        {
19795                            ios.imbue(lc);
19796                            {
19797                                ios.width(0);
19798                                {
19799                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19800                                    std::string ex(str, iter.base());
19801                                    assert(ex == "-0.0e+00");
19802                                    assert(ios.width() == 0);
19803                                }
19804                                ios.width(25);
19805                                left(ios);
19806                                {
19807                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19808                                    std::string ex(str, iter.base());
19809                                    assert(ex == "-0.0e+00*****************");
19810                                    assert(ios.width() == 0);
19811                                }
19812                                ios.width(25);
19813                                right(ios);
19814                                {
19815                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19816                                    std::string ex(str, iter.base());
19817                                    assert(ex == "*****************-0.0e+00");
19818                                    assert(ios.width() == 0);
19819                                }
19820                                ios.width(25);
19821                                internal(ios);
19822                                {
19823                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19824                                    std::string ex(str, iter.base());
19825                                    assert(ex == "-*****************0.0e+00");
19826                                    assert(ios.width() == 0);
19827                                }
19828                            }
19829                            ios.imbue(lg);
19830                            {
19831                                ios.width(0);
19832                                {
19833                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19834                                    std::string ex(str, iter.base());
19835                                    assert(ex == "-0;0e+00");
19836                                    assert(ios.width() == 0);
19837                                }
19838                                ios.width(25);
19839                                left(ios);
19840                                {
19841                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19842                                    std::string ex(str, iter.base());
19843                                    assert(ex == "-0;0e+00*****************");
19844                                    assert(ios.width() == 0);
19845                                }
19846                                ios.width(25);
19847                                right(ios);
19848                                {
19849                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19850                                    std::string ex(str, iter.base());
19851                                    assert(ex == "*****************-0;0e+00");
19852                                    assert(ios.width() == 0);
19853                                }
19854                                ios.width(25);
19855                                internal(ios);
19856                                {
19857                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19858                                    std::string ex(str, iter.base());
19859                                    assert(ex == "-*****************0;0e+00");
19860                                    assert(ios.width() == 0);
19861                                }
19862                            }
19863                        }
19864                        showpoint(ios);
19865                        {
19866                            ios.imbue(lc);
19867                            {
19868                                ios.width(0);
19869                                {
19870                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19871                                    std::string ex(str, iter.base());
19872                                    assert(ex == "-0.0e+00");
19873                                    assert(ios.width() == 0);
19874                                }
19875                                ios.width(25);
19876                                left(ios);
19877                                {
19878                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19879                                    std::string ex(str, iter.base());
19880                                    assert(ex == "-0.0e+00*****************");
19881                                    assert(ios.width() == 0);
19882                                }
19883                                ios.width(25);
19884                                right(ios);
19885                                {
19886                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19887                                    std::string ex(str, iter.base());
19888                                    assert(ex == "*****************-0.0e+00");
19889                                    assert(ios.width() == 0);
19890                                }
19891                                ios.width(25);
19892                                internal(ios);
19893                                {
19894                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19895                                    std::string ex(str, iter.base());
19896                                    assert(ex == "-*****************0.0e+00");
19897                                    assert(ios.width() == 0);
19898                                }
19899                            }
19900                            ios.imbue(lg);
19901                            {
19902                                ios.width(0);
19903                                {
19904                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19905                                    std::string ex(str, iter.base());
19906                                    assert(ex == "-0;0e+00");
19907                                    assert(ios.width() == 0);
19908                                }
19909                                ios.width(25);
19910                                left(ios);
19911                                {
19912                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19913                                    std::string ex(str, iter.base());
19914                                    assert(ex == "-0;0e+00*****************");
19915                                    assert(ios.width() == 0);
19916                                }
19917                                ios.width(25);
19918                                right(ios);
19919                                {
19920                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19921                                    std::string ex(str, iter.base());
19922                                    assert(ex == "*****************-0;0e+00");
19923                                    assert(ios.width() == 0);
19924                                }
19925                                ios.width(25);
19926                                internal(ios);
19927                                {
19928                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19929                                    std::string ex(str, iter.base());
19930                                    assert(ex == "-*****************0;0e+00");
19931                                    assert(ios.width() == 0);
19932                                }
19933                            }
19934                        }
19935                    }
19936                }
19937                uppercase(ios);
19938                {
19939                    noshowpos(ios);
19940                    {
19941                        noshowpoint(ios);
19942                        {
19943                            ios.imbue(lc);
19944                            {
19945                                ios.width(0);
19946                                {
19947                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19948                                    std::string ex(str, iter.base());
19949                                    assert(ex == "-0.0E+00");
19950                                    assert(ios.width() == 0);
19951                                }
19952                                ios.width(25);
19953                                left(ios);
19954                                {
19955                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19956                                    std::string ex(str, iter.base());
19957                                    assert(ex == "-0.0E+00*****************");
19958                                    assert(ios.width() == 0);
19959                                }
19960                                ios.width(25);
19961                                right(ios);
19962                                {
19963                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19964                                    std::string ex(str, iter.base());
19965                                    assert(ex == "*****************-0.0E+00");
19966                                    assert(ios.width() == 0);
19967                                }
19968                                ios.width(25);
19969                                internal(ios);
19970                                {
19971                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19972                                    std::string ex(str, iter.base());
19973                                    assert(ex == "-*****************0.0E+00");
19974                                    assert(ios.width() == 0);
19975                                }
19976                            }
19977                            ios.imbue(lg);
19978                            {
19979                                ios.width(0);
19980                                {
19981                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19982                                    std::string ex(str, iter.base());
19983                                    assert(ex == "-0;0E+00");
19984                                    assert(ios.width() == 0);
19985                                }
19986                                ios.width(25);
19987                                left(ios);
19988                                {
19989                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19990                                    std::string ex(str, iter.base());
19991                                    assert(ex == "-0;0E+00*****************");
19992                                    assert(ios.width() == 0);
19993                                }
19994                                ios.width(25);
19995                                right(ios);
19996                                {
19997                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
19998                                    std::string ex(str, iter.base());
19999                                    assert(ex == "*****************-0;0E+00");
20000                                    assert(ios.width() == 0);
20001                                }
20002                                ios.width(25);
20003                                internal(ios);
20004                                {
20005                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20006                                    std::string ex(str, iter.base());
20007                                    assert(ex == "-*****************0;0E+00");
20008                                    assert(ios.width() == 0);
20009                                }
20010                            }
20011                        }
20012                        showpoint(ios);
20013                        {
20014                            ios.imbue(lc);
20015                            {
20016                                ios.width(0);
20017                                {
20018                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20019                                    std::string ex(str, iter.base());
20020                                    assert(ex == "-0.0E+00");
20021                                    assert(ios.width() == 0);
20022                                }
20023                                ios.width(25);
20024                                left(ios);
20025                                {
20026                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20027                                    std::string ex(str, iter.base());
20028                                    assert(ex == "-0.0E+00*****************");
20029                                    assert(ios.width() == 0);
20030                                }
20031                                ios.width(25);
20032                                right(ios);
20033                                {
20034                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20035                                    std::string ex(str, iter.base());
20036                                    assert(ex == "*****************-0.0E+00");
20037                                    assert(ios.width() == 0);
20038                                }
20039                                ios.width(25);
20040                                internal(ios);
20041                                {
20042                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20043                                    std::string ex(str, iter.base());
20044                                    assert(ex == "-*****************0.0E+00");
20045                                    assert(ios.width() == 0);
20046                                }
20047                            }
20048                            ios.imbue(lg);
20049                            {
20050                                ios.width(0);
20051                                {
20052                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20053                                    std::string ex(str, iter.base());
20054                                    assert(ex == "-0;0E+00");
20055                                    assert(ios.width() == 0);
20056                                }
20057                                ios.width(25);
20058                                left(ios);
20059                                {
20060                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20061                                    std::string ex(str, iter.base());
20062                                    assert(ex == "-0;0E+00*****************");
20063                                    assert(ios.width() == 0);
20064                                }
20065                                ios.width(25);
20066                                right(ios);
20067                                {
20068                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20069                                    std::string ex(str, iter.base());
20070                                    assert(ex == "*****************-0;0E+00");
20071                                    assert(ios.width() == 0);
20072                                }
20073                                ios.width(25);
20074                                internal(ios);
20075                                {
20076                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20077                                    std::string ex(str, iter.base());
20078                                    assert(ex == "-*****************0;0E+00");
20079                                    assert(ios.width() == 0);
20080                                }
20081                            }
20082                        }
20083                    }
20084                    showpos(ios);
20085                    {
20086                        noshowpoint(ios);
20087                        {
20088                            ios.imbue(lc);
20089                            {
20090                                ios.width(0);
20091                                {
20092                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20093                                    std::string ex(str, iter.base());
20094                                    assert(ex == "-0.0E+00");
20095                                    assert(ios.width() == 0);
20096                                }
20097                                ios.width(25);
20098                                left(ios);
20099                                {
20100                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20101                                    std::string ex(str, iter.base());
20102                                    assert(ex == "-0.0E+00*****************");
20103                                    assert(ios.width() == 0);
20104                                }
20105                                ios.width(25);
20106                                right(ios);
20107                                {
20108                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20109                                    std::string ex(str, iter.base());
20110                                    assert(ex == "*****************-0.0E+00");
20111                                    assert(ios.width() == 0);
20112                                }
20113                                ios.width(25);
20114                                internal(ios);
20115                                {
20116                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20117                                    std::string ex(str, iter.base());
20118                                    assert(ex == "-*****************0.0E+00");
20119                                    assert(ios.width() == 0);
20120                                }
20121                            }
20122                            ios.imbue(lg);
20123                            {
20124                                ios.width(0);
20125                                {
20126                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20127                                    std::string ex(str, iter.base());
20128                                    assert(ex == "-0;0E+00");
20129                                    assert(ios.width() == 0);
20130                                }
20131                                ios.width(25);
20132                                left(ios);
20133                                {
20134                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20135                                    std::string ex(str, iter.base());
20136                                    assert(ex == "-0;0E+00*****************");
20137                                    assert(ios.width() == 0);
20138                                }
20139                                ios.width(25);
20140                                right(ios);
20141                                {
20142                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20143                                    std::string ex(str, iter.base());
20144                                    assert(ex == "*****************-0;0E+00");
20145                                    assert(ios.width() == 0);
20146                                }
20147                                ios.width(25);
20148                                internal(ios);
20149                                {
20150                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20151                                    std::string ex(str, iter.base());
20152                                    assert(ex == "-*****************0;0E+00");
20153                                    assert(ios.width() == 0);
20154                                }
20155                            }
20156                        }
20157                        showpoint(ios);
20158                        {
20159                            ios.imbue(lc);
20160                            {
20161                                ios.width(0);
20162                                {
20163                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20164                                    std::string ex(str, iter.base());
20165                                    assert(ex == "-0.0E+00");
20166                                    assert(ios.width() == 0);
20167                                }
20168                                ios.width(25);
20169                                left(ios);
20170                                {
20171                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20172                                    std::string ex(str, iter.base());
20173                                    assert(ex == "-0.0E+00*****************");
20174                                    assert(ios.width() == 0);
20175                                }
20176                                ios.width(25);
20177                                right(ios);
20178                                {
20179                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20180                                    std::string ex(str, iter.base());
20181                                    assert(ex == "*****************-0.0E+00");
20182                                    assert(ios.width() == 0);
20183                                }
20184                                ios.width(25);
20185                                internal(ios);
20186                                {
20187                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20188                                    std::string ex(str, iter.base());
20189                                    assert(ex == "-*****************0.0E+00");
20190                                    assert(ios.width() == 0);
20191                                }
20192                            }
20193                            ios.imbue(lg);
20194                            {
20195                                ios.width(0);
20196                                {
20197                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20198                                    std::string ex(str, iter.base());
20199                                    assert(ex == "-0;0E+00");
20200                                    assert(ios.width() == 0);
20201                                }
20202                                ios.width(25);
20203                                left(ios);
20204                                {
20205                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20206                                    std::string ex(str, iter.base());
20207                                    assert(ex == "-0;0E+00*****************");
20208                                    assert(ios.width() == 0);
20209                                }
20210                                ios.width(25);
20211                                right(ios);
20212                                {
20213                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20214                                    std::string ex(str, iter.base());
20215                                    assert(ex == "*****************-0;0E+00");
20216                                    assert(ios.width() == 0);
20217                                }
20218                                ios.width(25);
20219                                internal(ios);
20220                                {
20221                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20222                                    std::string ex(str, iter.base());
20223                                    assert(ex == "-*****************0;0E+00");
20224                                    assert(ios.width() == 0);
20225                                }
20226                            }
20227                        }
20228                    }
20229                }
20230            }
20231            ios.precision(6);
20232            {
20233                nouppercase(ios);
20234                {
20235                    noshowpos(ios);
20236                    {
20237                        noshowpoint(ios);
20238                        {
20239                            ios.imbue(lc);
20240                            {
20241                                ios.width(0);
20242                                {
20243                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20244                                    std::string ex(str, iter.base());
20245                                    assert(ex == "-0.000000e+00");
20246                                    assert(ios.width() == 0);
20247                                }
20248                                ios.width(25);
20249                                left(ios);
20250                                {
20251                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20252                                    std::string ex(str, iter.base());
20253                                    assert(ex == "-0.000000e+00************");
20254                                    assert(ios.width() == 0);
20255                                }
20256                                ios.width(25);
20257                                right(ios);
20258                                {
20259                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20260                                    std::string ex(str, iter.base());
20261                                    assert(ex == "************-0.000000e+00");
20262                                    assert(ios.width() == 0);
20263                                }
20264                                ios.width(25);
20265                                internal(ios);
20266                                {
20267                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20268                                    std::string ex(str, iter.base());
20269                                    assert(ex == "-************0.000000e+00");
20270                                    assert(ios.width() == 0);
20271                                }
20272                            }
20273                            ios.imbue(lg);
20274                            {
20275                                ios.width(0);
20276                                {
20277                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20278                                    std::string ex(str, iter.base());
20279                                    assert(ex == "-0;000000e+00");
20280                                    assert(ios.width() == 0);
20281                                }
20282                                ios.width(25);
20283                                left(ios);
20284                                {
20285                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20286                                    std::string ex(str, iter.base());
20287                                    assert(ex == "-0;000000e+00************");
20288                                    assert(ios.width() == 0);
20289                                }
20290                                ios.width(25);
20291                                right(ios);
20292                                {
20293                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20294                                    std::string ex(str, iter.base());
20295                                    assert(ex == "************-0;000000e+00");
20296                                    assert(ios.width() == 0);
20297                                }
20298                                ios.width(25);
20299                                internal(ios);
20300                                {
20301                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20302                                    std::string ex(str, iter.base());
20303                                    assert(ex == "-************0;000000e+00");
20304                                    assert(ios.width() == 0);
20305                                }
20306                            }
20307                        }
20308                        showpoint(ios);
20309                        {
20310                            ios.imbue(lc);
20311                            {
20312                                ios.width(0);
20313                                {
20314                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20315                                    std::string ex(str, iter.base());
20316                                    assert(ex == "-0.000000e+00");
20317                                    assert(ios.width() == 0);
20318                                }
20319                                ios.width(25);
20320                                left(ios);
20321                                {
20322                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20323                                    std::string ex(str, iter.base());
20324                                    assert(ex == "-0.000000e+00************");
20325                                    assert(ios.width() == 0);
20326                                }
20327                                ios.width(25);
20328                                right(ios);
20329                                {
20330                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20331                                    std::string ex(str, iter.base());
20332                                    assert(ex == "************-0.000000e+00");
20333                                    assert(ios.width() == 0);
20334                                }
20335                                ios.width(25);
20336                                internal(ios);
20337                                {
20338                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20339                                    std::string ex(str, iter.base());
20340                                    assert(ex == "-************0.000000e+00");
20341                                    assert(ios.width() == 0);
20342                                }
20343                            }
20344                            ios.imbue(lg);
20345                            {
20346                                ios.width(0);
20347                                {
20348                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20349                                    std::string ex(str, iter.base());
20350                                    assert(ex == "-0;000000e+00");
20351                                    assert(ios.width() == 0);
20352                                }
20353                                ios.width(25);
20354                                left(ios);
20355                                {
20356                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20357                                    std::string ex(str, iter.base());
20358                                    assert(ex == "-0;000000e+00************");
20359                                    assert(ios.width() == 0);
20360                                }
20361                                ios.width(25);
20362                                right(ios);
20363                                {
20364                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20365                                    std::string ex(str, iter.base());
20366                                    assert(ex == "************-0;000000e+00");
20367                                    assert(ios.width() == 0);
20368                                }
20369                                ios.width(25);
20370                                internal(ios);
20371                                {
20372                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20373                                    std::string ex(str, iter.base());
20374                                    assert(ex == "-************0;000000e+00");
20375                                    assert(ios.width() == 0);
20376                                }
20377                            }
20378                        }
20379                    }
20380                    showpos(ios);
20381                    {
20382                        noshowpoint(ios);
20383                        {
20384                            ios.imbue(lc);
20385                            {
20386                                ios.width(0);
20387                                {
20388                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20389                                    std::string ex(str, iter.base());
20390                                    assert(ex == "-0.000000e+00");
20391                                    assert(ios.width() == 0);
20392                                }
20393                                ios.width(25);
20394                                left(ios);
20395                                {
20396                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20397                                    std::string ex(str, iter.base());
20398                                    assert(ex == "-0.000000e+00************");
20399                                    assert(ios.width() == 0);
20400                                }
20401                                ios.width(25);
20402                                right(ios);
20403                                {
20404                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20405                                    std::string ex(str, iter.base());
20406                                    assert(ex == "************-0.000000e+00");
20407                                    assert(ios.width() == 0);
20408                                }
20409                                ios.width(25);
20410                                internal(ios);
20411                                {
20412                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20413                                    std::string ex(str, iter.base());
20414                                    assert(ex == "-************0.000000e+00");
20415                                    assert(ios.width() == 0);
20416                                }
20417                            }
20418                            ios.imbue(lg);
20419                            {
20420                                ios.width(0);
20421                                {
20422                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20423                                    std::string ex(str, iter.base());
20424                                    assert(ex == "-0;000000e+00");
20425                                    assert(ios.width() == 0);
20426                                }
20427                                ios.width(25);
20428                                left(ios);
20429                                {
20430                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20431                                    std::string ex(str, iter.base());
20432                                    assert(ex == "-0;000000e+00************");
20433                                    assert(ios.width() == 0);
20434                                }
20435                                ios.width(25);
20436                                right(ios);
20437                                {
20438                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20439                                    std::string ex(str, iter.base());
20440                                    assert(ex == "************-0;000000e+00");
20441                                    assert(ios.width() == 0);
20442                                }
20443                                ios.width(25);
20444                                internal(ios);
20445                                {
20446                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20447                                    std::string ex(str, iter.base());
20448                                    assert(ex == "-************0;000000e+00");
20449                                    assert(ios.width() == 0);
20450                                }
20451                            }
20452                        }
20453                        showpoint(ios);
20454                        {
20455                            ios.imbue(lc);
20456                            {
20457                                ios.width(0);
20458                                {
20459                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20460                                    std::string ex(str, iter.base());
20461                                    assert(ex == "-0.000000e+00");
20462                                    assert(ios.width() == 0);
20463                                }
20464                                ios.width(25);
20465                                left(ios);
20466                                {
20467                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20468                                    std::string ex(str, iter.base());
20469                                    assert(ex == "-0.000000e+00************");
20470                                    assert(ios.width() == 0);
20471                                }
20472                                ios.width(25);
20473                                right(ios);
20474                                {
20475                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20476                                    std::string ex(str, iter.base());
20477                                    assert(ex == "************-0.000000e+00");
20478                                    assert(ios.width() == 0);
20479                                }
20480                                ios.width(25);
20481                                internal(ios);
20482                                {
20483                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20484                                    std::string ex(str, iter.base());
20485                                    assert(ex == "-************0.000000e+00");
20486                                    assert(ios.width() == 0);
20487                                }
20488                            }
20489                            ios.imbue(lg);
20490                            {
20491                                ios.width(0);
20492                                {
20493                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20494                                    std::string ex(str, iter.base());
20495                                    assert(ex == "-0;000000e+00");
20496                                    assert(ios.width() == 0);
20497                                }
20498                                ios.width(25);
20499                                left(ios);
20500                                {
20501                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20502                                    std::string ex(str, iter.base());
20503                                    assert(ex == "-0;000000e+00************");
20504                                    assert(ios.width() == 0);
20505                                }
20506                                ios.width(25);
20507                                right(ios);
20508                                {
20509                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20510                                    std::string ex(str, iter.base());
20511                                    assert(ex == "************-0;000000e+00");
20512                                    assert(ios.width() == 0);
20513                                }
20514                                ios.width(25);
20515                                internal(ios);
20516                                {
20517                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20518                                    std::string ex(str, iter.base());
20519                                    assert(ex == "-************0;000000e+00");
20520                                    assert(ios.width() == 0);
20521                                }
20522                            }
20523                        }
20524                    }
20525                }
20526                uppercase(ios);
20527                {
20528                    noshowpos(ios);
20529                    {
20530                        noshowpoint(ios);
20531                        {
20532                            ios.imbue(lc);
20533                            {
20534                                ios.width(0);
20535                                {
20536                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20537                                    std::string ex(str, iter.base());
20538                                    assert(ex == "-0.000000E+00");
20539                                    assert(ios.width() == 0);
20540                                }
20541                                ios.width(25);
20542                                left(ios);
20543                                {
20544                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20545                                    std::string ex(str, iter.base());
20546                                    assert(ex == "-0.000000E+00************");
20547                                    assert(ios.width() == 0);
20548                                }
20549                                ios.width(25);
20550                                right(ios);
20551                                {
20552                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20553                                    std::string ex(str, iter.base());
20554                                    assert(ex == "************-0.000000E+00");
20555                                    assert(ios.width() == 0);
20556                                }
20557                                ios.width(25);
20558                                internal(ios);
20559                                {
20560                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20561                                    std::string ex(str, iter.base());
20562                                    assert(ex == "-************0.000000E+00");
20563                                    assert(ios.width() == 0);
20564                                }
20565                            }
20566                            ios.imbue(lg);
20567                            {
20568                                ios.width(0);
20569                                {
20570                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20571                                    std::string ex(str, iter.base());
20572                                    assert(ex == "-0;000000E+00");
20573                                    assert(ios.width() == 0);
20574                                }
20575                                ios.width(25);
20576                                left(ios);
20577                                {
20578                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20579                                    std::string ex(str, iter.base());
20580                                    assert(ex == "-0;000000E+00************");
20581                                    assert(ios.width() == 0);
20582                                }
20583                                ios.width(25);
20584                                right(ios);
20585                                {
20586                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20587                                    std::string ex(str, iter.base());
20588                                    assert(ex == "************-0;000000E+00");
20589                                    assert(ios.width() == 0);
20590                                }
20591                                ios.width(25);
20592                                internal(ios);
20593                                {
20594                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20595                                    std::string ex(str, iter.base());
20596                                    assert(ex == "-************0;000000E+00");
20597                                    assert(ios.width() == 0);
20598                                }
20599                            }
20600                        }
20601                        showpoint(ios);
20602                        {
20603                            ios.imbue(lc);
20604                            {
20605                                ios.width(0);
20606                                {
20607                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20608                                    std::string ex(str, iter.base());
20609                                    assert(ex == "-0.000000E+00");
20610                                    assert(ios.width() == 0);
20611                                }
20612                                ios.width(25);
20613                                left(ios);
20614                                {
20615                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20616                                    std::string ex(str, iter.base());
20617                                    assert(ex == "-0.000000E+00************");
20618                                    assert(ios.width() == 0);
20619                                }
20620                                ios.width(25);
20621                                right(ios);
20622                                {
20623                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20624                                    std::string ex(str, iter.base());
20625                                    assert(ex == "************-0.000000E+00");
20626                                    assert(ios.width() == 0);
20627                                }
20628                                ios.width(25);
20629                                internal(ios);
20630                                {
20631                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20632                                    std::string ex(str, iter.base());
20633                                    assert(ex == "-************0.000000E+00");
20634                                    assert(ios.width() == 0);
20635                                }
20636                            }
20637                            ios.imbue(lg);
20638                            {
20639                                ios.width(0);
20640                                {
20641                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20642                                    std::string ex(str, iter.base());
20643                                    assert(ex == "-0;000000E+00");
20644                                    assert(ios.width() == 0);
20645                                }
20646                                ios.width(25);
20647                                left(ios);
20648                                {
20649                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20650                                    std::string ex(str, iter.base());
20651                                    assert(ex == "-0;000000E+00************");
20652                                    assert(ios.width() == 0);
20653                                }
20654                                ios.width(25);
20655                                right(ios);
20656                                {
20657                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20658                                    std::string ex(str, iter.base());
20659                                    assert(ex == "************-0;000000E+00");
20660                                    assert(ios.width() == 0);
20661                                }
20662                                ios.width(25);
20663                                internal(ios);
20664                                {
20665                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20666                                    std::string ex(str, iter.base());
20667                                    assert(ex == "-************0;000000E+00");
20668                                    assert(ios.width() == 0);
20669                                }
20670                            }
20671                        }
20672                    }
20673                    showpos(ios);
20674                    {
20675                        noshowpoint(ios);
20676                        {
20677                            ios.imbue(lc);
20678                            {
20679                                ios.width(0);
20680                                {
20681                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20682                                    std::string ex(str, iter.base());
20683                                    assert(ex == "-0.000000E+00");
20684                                    assert(ios.width() == 0);
20685                                }
20686                                ios.width(25);
20687                                left(ios);
20688                                {
20689                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20690                                    std::string ex(str, iter.base());
20691                                    assert(ex == "-0.000000E+00************");
20692                                    assert(ios.width() == 0);
20693                                }
20694                                ios.width(25);
20695                                right(ios);
20696                                {
20697                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20698                                    std::string ex(str, iter.base());
20699                                    assert(ex == "************-0.000000E+00");
20700                                    assert(ios.width() == 0);
20701                                }
20702                                ios.width(25);
20703                                internal(ios);
20704                                {
20705                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20706                                    std::string ex(str, iter.base());
20707                                    assert(ex == "-************0.000000E+00");
20708                                    assert(ios.width() == 0);
20709                                }
20710                            }
20711                            ios.imbue(lg);
20712                            {
20713                                ios.width(0);
20714                                {
20715                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20716                                    std::string ex(str, iter.base());
20717                                    assert(ex == "-0;000000E+00");
20718                                    assert(ios.width() == 0);
20719                                }
20720                                ios.width(25);
20721                                left(ios);
20722                                {
20723                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20724                                    std::string ex(str, iter.base());
20725                                    assert(ex == "-0;000000E+00************");
20726                                    assert(ios.width() == 0);
20727                                }
20728                                ios.width(25);
20729                                right(ios);
20730                                {
20731                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20732                                    std::string ex(str, iter.base());
20733                                    assert(ex == "************-0;000000E+00");
20734                                    assert(ios.width() == 0);
20735                                }
20736                                ios.width(25);
20737                                internal(ios);
20738                                {
20739                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20740                                    std::string ex(str, iter.base());
20741                                    assert(ex == "-************0;000000E+00");
20742                                    assert(ios.width() == 0);
20743                                }
20744                            }
20745                        }
20746                        showpoint(ios);
20747                        {
20748                            ios.imbue(lc);
20749                            {
20750                                ios.width(0);
20751                                {
20752                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20753                                    std::string ex(str, iter.base());
20754                                    assert(ex == "-0.000000E+00");
20755                                    assert(ios.width() == 0);
20756                                }
20757                                ios.width(25);
20758                                left(ios);
20759                                {
20760                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20761                                    std::string ex(str, iter.base());
20762                                    assert(ex == "-0.000000E+00************");
20763                                    assert(ios.width() == 0);
20764                                }
20765                                ios.width(25);
20766                                right(ios);
20767                                {
20768                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20769                                    std::string ex(str, iter.base());
20770                                    assert(ex == "************-0.000000E+00");
20771                                    assert(ios.width() == 0);
20772                                }
20773                                ios.width(25);
20774                                internal(ios);
20775                                {
20776                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20777                                    std::string ex(str, iter.base());
20778                                    assert(ex == "-************0.000000E+00");
20779                                    assert(ios.width() == 0);
20780                                }
20781                            }
20782                            ios.imbue(lg);
20783                            {
20784                                ios.width(0);
20785                                {
20786                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20787                                    std::string ex(str, iter.base());
20788                                    assert(ex == "-0;000000E+00");
20789                                    assert(ios.width() == 0);
20790                                }
20791                                ios.width(25);
20792                                left(ios);
20793                                {
20794                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20795                                    std::string ex(str, iter.base());
20796                                    assert(ex == "-0;000000E+00************");
20797                                    assert(ios.width() == 0);
20798                                }
20799                                ios.width(25);
20800                                right(ios);
20801                                {
20802                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20803                                    std::string ex(str, iter.base());
20804                                    assert(ex == "************-0;000000E+00");
20805                                    assert(ios.width() == 0);
20806                                }
20807                                ios.width(25);
20808                                internal(ios);
20809                                {
20810                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20811                                    std::string ex(str, iter.base());
20812                                    assert(ex == "-************0;000000E+00");
20813                                    assert(ios.width() == 0);
20814                                }
20815                            }
20816                        }
20817                    }
20818                }
20819            }
20820            ios.precision(16);
20821            {
20822            }
20823            ios.precision(60);
20824            {
20825            }
20826        }
20827    }
20828}
20829
20830void test10()
20831{
20832    char str[200];
20833    output_iterator<char*> iter;
20834    std::locale lc = std::locale::classic();
20835    std::locale lg(lc, new my_numpunct);
20836    const my_facet f(1);
20837    {
20838        long double v = 1234567890.125;
20839        std::ios ios(0);
20840        scientific(ios);
20841        // %e
20842        {
20843            ios.precision(0);
20844            {
20845                nouppercase(ios);
20846                {
20847                    noshowpos(ios);
20848                    {
20849                        noshowpoint(ios);
20850                        {
20851                            ios.imbue(lc);
20852                            {
20853                                ios.width(0);
20854                                {
20855                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20856                                    std::string ex(str, iter.base());
20857                                    assert(ex == "1e+09");
20858                                    assert(ios.width() == 0);
20859                                }
20860                                ios.width(25);
20861                                left(ios);
20862                                {
20863                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20864                                    std::string ex(str, iter.base());
20865                                    assert(ex == "1e+09********************");
20866                                    assert(ios.width() == 0);
20867                                }
20868                                ios.width(25);
20869                                right(ios);
20870                                {
20871                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20872                                    std::string ex(str, iter.base());
20873                                    assert(ex == "********************1e+09");
20874                                    assert(ios.width() == 0);
20875                                }
20876                                ios.width(25);
20877                                internal(ios);
20878                                {
20879                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20880                                    std::string ex(str, iter.base());
20881                                    assert(ex == "********************1e+09");
20882                                    assert(ios.width() == 0);
20883                                }
20884                            }
20885                            ios.imbue(lg);
20886                            {
20887                                ios.width(0);
20888                                {
20889                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20890                                    std::string ex(str, iter.base());
20891                                    assert(ex == "1e+09");
20892                                    assert(ios.width() == 0);
20893                                }
20894                                ios.width(25);
20895                                left(ios);
20896                                {
20897                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20898                                    std::string ex(str, iter.base());
20899                                    assert(ex == "1e+09********************");
20900                                    assert(ios.width() == 0);
20901                                }
20902                                ios.width(25);
20903                                right(ios);
20904                                {
20905                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20906                                    std::string ex(str, iter.base());
20907                                    assert(ex == "********************1e+09");
20908                                    assert(ios.width() == 0);
20909                                }
20910                                ios.width(25);
20911                                internal(ios);
20912                                {
20913                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20914                                    std::string ex(str, iter.base());
20915                                    assert(ex == "********************1e+09");
20916                                    assert(ios.width() == 0);
20917                                }
20918                            }
20919                        }
20920                        showpoint(ios);
20921                        {
20922                            ios.imbue(lc);
20923                            {
20924                                ios.width(0);
20925                                {
20926                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20927                                    std::string ex(str, iter.base());
20928                                    assert(ex == "1.e+09");
20929                                    assert(ios.width() == 0);
20930                                }
20931                                ios.width(25);
20932                                left(ios);
20933                                {
20934                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20935                                    std::string ex(str, iter.base());
20936                                    assert(ex == "1.e+09*******************");
20937                                    assert(ios.width() == 0);
20938                                }
20939                                ios.width(25);
20940                                right(ios);
20941                                {
20942                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20943                                    std::string ex(str, iter.base());
20944                                    assert(ex == "*******************1.e+09");
20945                                    assert(ios.width() == 0);
20946                                }
20947                                ios.width(25);
20948                                internal(ios);
20949                                {
20950                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20951                                    std::string ex(str, iter.base());
20952                                    assert(ex == "*******************1.e+09");
20953                                    assert(ios.width() == 0);
20954                                }
20955                            }
20956                            ios.imbue(lg);
20957                            {
20958                                ios.width(0);
20959                                {
20960                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20961                                    std::string ex(str, iter.base());
20962                                    assert(ex == "1;e+09");
20963                                    assert(ios.width() == 0);
20964                                }
20965                                ios.width(25);
20966                                left(ios);
20967                                {
20968                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20969                                    std::string ex(str, iter.base());
20970                                    assert(ex == "1;e+09*******************");
20971                                    assert(ios.width() == 0);
20972                                }
20973                                ios.width(25);
20974                                right(ios);
20975                                {
20976                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20977                                    std::string ex(str, iter.base());
20978                                    assert(ex == "*******************1;e+09");
20979                                    assert(ios.width() == 0);
20980                                }
20981                                ios.width(25);
20982                                internal(ios);
20983                                {
20984                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
20985                                    std::string ex(str, iter.base());
20986                                    assert(ex == "*******************1;e+09");
20987                                    assert(ios.width() == 0);
20988                                }
20989                            }
20990                        }
20991                    }
20992                    showpos(ios);
20993                    {
20994                        noshowpoint(ios);
20995                        {
20996                            ios.imbue(lc);
20997                            {
20998                                ios.width(0);
20999                                {
21000                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21001                                    std::string ex(str, iter.base());
21002                                    assert(ex == "+1e+09");
21003                                    assert(ios.width() == 0);
21004                                }
21005                                ios.width(25);
21006                                left(ios);
21007                                {
21008                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21009                                    std::string ex(str, iter.base());
21010                                    assert(ex == "+1e+09*******************");
21011                                    assert(ios.width() == 0);
21012                                }
21013                                ios.width(25);
21014                                right(ios);
21015                                {
21016                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21017                                    std::string ex(str, iter.base());
21018                                    assert(ex == "*******************+1e+09");
21019                                    assert(ios.width() == 0);
21020                                }
21021                                ios.width(25);
21022                                internal(ios);
21023                                {
21024                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21025                                    std::string ex(str, iter.base());
21026                                    assert(ex == "+*******************1e+09");
21027                                    assert(ios.width() == 0);
21028                                }
21029                            }
21030                            ios.imbue(lg);
21031                            {
21032                                ios.width(0);
21033                                {
21034                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21035                                    std::string ex(str, iter.base());
21036                                    assert(ex == "+1e+09");
21037                                    assert(ios.width() == 0);
21038                                }
21039                                ios.width(25);
21040                                left(ios);
21041                                {
21042                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21043                                    std::string ex(str, iter.base());
21044                                    assert(ex == "+1e+09*******************");
21045                                    assert(ios.width() == 0);
21046                                }
21047                                ios.width(25);
21048                                right(ios);
21049                                {
21050                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21051                                    std::string ex(str, iter.base());
21052                                    assert(ex == "*******************+1e+09");
21053                                    assert(ios.width() == 0);
21054                                }
21055                                ios.width(25);
21056                                internal(ios);
21057                                {
21058                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21059                                    std::string ex(str, iter.base());
21060                                    assert(ex == "+*******************1e+09");
21061                                    assert(ios.width() == 0);
21062                                }
21063                            }
21064                        }
21065                        showpoint(ios);
21066                        {
21067                            ios.imbue(lc);
21068                            {
21069                                ios.width(0);
21070                                {
21071                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21072                                    std::string ex(str, iter.base());
21073                                    assert(ex == "+1.e+09");
21074                                    assert(ios.width() == 0);
21075                                }
21076                                ios.width(25);
21077                                left(ios);
21078                                {
21079                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21080                                    std::string ex(str, iter.base());
21081                                    assert(ex == "+1.e+09******************");
21082                                    assert(ios.width() == 0);
21083                                }
21084                                ios.width(25);
21085                                right(ios);
21086                                {
21087                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21088                                    std::string ex(str, iter.base());
21089                                    assert(ex == "******************+1.e+09");
21090                                    assert(ios.width() == 0);
21091                                }
21092                                ios.width(25);
21093                                internal(ios);
21094                                {
21095                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21096                                    std::string ex(str, iter.base());
21097                                    assert(ex == "+******************1.e+09");
21098                                    assert(ios.width() == 0);
21099                                }
21100                            }
21101                            ios.imbue(lg);
21102                            {
21103                                ios.width(0);
21104                                {
21105                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21106                                    std::string ex(str, iter.base());
21107                                    assert(ex == "+1;e+09");
21108                                    assert(ios.width() == 0);
21109                                }
21110                                ios.width(25);
21111                                left(ios);
21112                                {
21113                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21114                                    std::string ex(str, iter.base());
21115                                    assert(ex == "+1;e+09******************");
21116                                    assert(ios.width() == 0);
21117                                }
21118                                ios.width(25);
21119                                right(ios);
21120                                {
21121                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21122                                    std::string ex(str, iter.base());
21123                                    assert(ex == "******************+1;e+09");
21124                                    assert(ios.width() == 0);
21125                                }
21126                                ios.width(25);
21127                                internal(ios);
21128                                {
21129                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21130                                    std::string ex(str, iter.base());
21131                                    assert(ex == "+******************1;e+09");
21132                                    assert(ios.width() == 0);
21133                                }
21134                            }
21135                        }
21136                    }
21137                }
21138                uppercase(ios);
21139                {
21140                    noshowpos(ios);
21141                    {
21142                        noshowpoint(ios);
21143                        {
21144                            ios.imbue(lc);
21145                            {
21146                                ios.width(0);
21147                                {
21148                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21149                                    std::string ex(str, iter.base());
21150                                    assert(ex == "1E+09");
21151                                    assert(ios.width() == 0);
21152                                }
21153                                ios.width(25);
21154                                left(ios);
21155                                {
21156                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21157                                    std::string ex(str, iter.base());
21158                                    assert(ex == "1E+09********************");
21159                                    assert(ios.width() == 0);
21160                                }
21161                                ios.width(25);
21162                                right(ios);
21163                                {
21164                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21165                                    std::string ex(str, iter.base());
21166                                    assert(ex == "********************1E+09");
21167                                    assert(ios.width() == 0);
21168                                }
21169                                ios.width(25);
21170                                internal(ios);
21171                                {
21172                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21173                                    std::string ex(str, iter.base());
21174                                    assert(ex == "********************1E+09");
21175                                    assert(ios.width() == 0);
21176                                }
21177                            }
21178                            ios.imbue(lg);
21179                            {
21180                                ios.width(0);
21181                                {
21182                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21183                                    std::string ex(str, iter.base());
21184                                    assert(ex == "1E+09");
21185                                    assert(ios.width() == 0);
21186                                }
21187                                ios.width(25);
21188                                left(ios);
21189                                {
21190                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21191                                    std::string ex(str, iter.base());
21192                                    assert(ex == "1E+09********************");
21193                                    assert(ios.width() == 0);
21194                                }
21195                                ios.width(25);
21196                                right(ios);
21197                                {
21198                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21199                                    std::string ex(str, iter.base());
21200                                    assert(ex == "********************1E+09");
21201                                    assert(ios.width() == 0);
21202                                }
21203                                ios.width(25);
21204                                internal(ios);
21205                                {
21206                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21207                                    std::string ex(str, iter.base());
21208                                    assert(ex == "********************1E+09");
21209                                    assert(ios.width() == 0);
21210                                }
21211                            }
21212                        }
21213                        showpoint(ios);
21214                        {
21215                            ios.imbue(lc);
21216                            {
21217                                ios.width(0);
21218                                {
21219                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21220                                    std::string ex(str, iter.base());
21221                                    assert(ex == "1.E+09");
21222                                    assert(ios.width() == 0);
21223                                }
21224                                ios.width(25);
21225                                left(ios);
21226                                {
21227                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21228                                    std::string ex(str, iter.base());
21229                                    assert(ex == "1.E+09*******************");
21230                                    assert(ios.width() == 0);
21231                                }
21232                                ios.width(25);
21233                                right(ios);
21234                                {
21235                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21236                                    std::string ex(str, iter.base());
21237                                    assert(ex == "*******************1.E+09");
21238                                    assert(ios.width() == 0);
21239                                }
21240                                ios.width(25);
21241                                internal(ios);
21242                                {
21243                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21244                                    std::string ex(str, iter.base());
21245                                    assert(ex == "*******************1.E+09");
21246                                    assert(ios.width() == 0);
21247                                }
21248                            }
21249                            ios.imbue(lg);
21250                            {
21251                                ios.width(0);
21252                                {
21253                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21254                                    std::string ex(str, iter.base());
21255                                    assert(ex == "1;E+09");
21256                                    assert(ios.width() == 0);
21257                                }
21258                                ios.width(25);
21259                                left(ios);
21260                                {
21261                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21262                                    std::string ex(str, iter.base());
21263                                    assert(ex == "1;E+09*******************");
21264                                    assert(ios.width() == 0);
21265                                }
21266                                ios.width(25);
21267                                right(ios);
21268                                {
21269                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21270                                    std::string ex(str, iter.base());
21271                                    assert(ex == "*******************1;E+09");
21272                                    assert(ios.width() == 0);
21273                                }
21274                                ios.width(25);
21275                                internal(ios);
21276                                {
21277                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21278                                    std::string ex(str, iter.base());
21279                                    assert(ex == "*******************1;E+09");
21280                                    assert(ios.width() == 0);
21281                                }
21282                            }
21283                        }
21284                    }
21285                    showpos(ios);
21286                    {
21287                        noshowpoint(ios);
21288                        {
21289                            ios.imbue(lc);
21290                            {
21291                                ios.width(0);
21292                                {
21293                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21294                                    std::string ex(str, iter.base());
21295                                    assert(ex == "+1E+09");
21296                                    assert(ios.width() == 0);
21297                                }
21298                                ios.width(25);
21299                                left(ios);
21300                                {
21301                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21302                                    std::string ex(str, iter.base());
21303                                    assert(ex == "+1E+09*******************");
21304                                    assert(ios.width() == 0);
21305                                }
21306                                ios.width(25);
21307                                right(ios);
21308                                {
21309                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21310                                    std::string ex(str, iter.base());
21311                                    assert(ex == "*******************+1E+09");
21312                                    assert(ios.width() == 0);
21313                                }
21314                                ios.width(25);
21315                                internal(ios);
21316                                {
21317                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21318                                    std::string ex(str, iter.base());
21319                                    assert(ex == "+*******************1E+09");
21320                                    assert(ios.width() == 0);
21321                                }
21322                            }
21323                            ios.imbue(lg);
21324                            {
21325                                ios.width(0);
21326                                {
21327                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21328                                    std::string ex(str, iter.base());
21329                                    assert(ex == "+1E+09");
21330                                    assert(ios.width() == 0);
21331                                }
21332                                ios.width(25);
21333                                left(ios);
21334                                {
21335                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21336                                    std::string ex(str, iter.base());
21337                                    assert(ex == "+1E+09*******************");
21338                                    assert(ios.width() == 0);
21339                                }
21340                                ios.width(25);
21341                                right(ios);
21342                                {
21343                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21344                                    std::string ex(str, iter.base());
21345                                    assert(ex == "*******************+1E+09");
21346                                    assert(ios.width() == 0);
21347                                }
21348                                ios.width(25);
21349                                internal(ios);
21350                                {
21351                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21352                                    std::string ex(str, iter.base());
21353                                    assert(ex == "+*******************1E+09");
21354                                    assert(ios.width() == 0);
21355                                }
21356                            }
21357                        }
21358                        showpoint(ios);
21359                        {
21360                            ios.imbue(lc);
21361                            {
21362                                ios.width(0);
21363                                {
21364                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21365                                    std::string ex(str, iter.base());
21366                                    assert(ex == "+1.E+09");
21367                                    assert(ios.width() == 0);
21368                                }
21369                                ios.width(25);
21370                                left(ios);
21371                                {
21372                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21373                                    std::string ex(str, iter.base());
21374                                    assert(ex == "+1.E+09******************");
21375                                    assert(ios.width() == 0);
21376                                }
21377                                ios.width(25);
21378                                right(ios);
21379                                {
21380                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21381                                    std::string ex(str, iter.base());
21382                                    assert(ex == "******************+1.E+09");
21383                                    assert(ios.width() == 0);
21384                                }
21385                                ios.width(25);
21386                                internal(ios);
21387                                {
21388                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21389                                    std::string ex(str, iter.base());
21390                                    assert(ex == "+******************1.E+09");
21391                                    assert(ios.width() == 0);
21392                                }
21393                            }
21394                            ios.imbue(lg);
21395                            {
21396                                ios.width(0);
21397                                {
21398                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21399                                    std::string ex(str, iter.base());
21400                                    assert(ex == "+1;E+09");
21401                                    assert(ios.width() == 0);
21402                                }
21403                                ios.width(25);
21404                                left(ios);
21405                                {
21406                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21407                                    std::string ex(str, iter.base());
21408                                    assert(ex == "+1;E+09******************");
21409                                    assert(ios.width() == 0);
21410                                }
21411                                ios.width(25);
21412                                right(ios);
21413                                {
21414                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21415                                    std::string ex(str, iter.base());
21416                                    assert(ex == "******************+1;E+09");
21417                                    assert(ios.width() == 0);
21418                                }
21419                                ios.width(25);
21420                                internal(ios);
21421                                {
21422                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21423                                    std::string ex(str, iter.base());
21424                                    assert(ex == "+******************1;E+09");
21425                                    assert(ios.width() == 0);
21426                                }
21427                            }
21428                        }
21429                    }
21430                }
21431            }
21432            ios.precision(1);
21433            {
21434                nouppercase(ios);
21435                {
21436                    noshowpos(ios);
21437                    {
21438                        noshowpoint(ios);
21439                        {
21440                            ios.imbue(lc);
21441                            {
21442                                ios.width(0);
21443                                {
21444                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21445                                    std::string ex(str, iter.base());
21446                                    assert(ex == "1.2e+09");
21447                                    assert(ios.width() == 0);
21448                                }
21449                                ios.width(25);
21450                                left(ios);
21451                                {
21452                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21453                                    std::string ex(str, iter.base());
21454                                    assert(ex == "1.2e+09******************");
21455                                    assert(ios.width() == 0);
21456                                }
21457                                ios.width(25);
21458                                right(ios);
21459                                {
21460                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21461                                    std::string ex(str, iter.base());
21462                                    assert(ex == "******************1.2e+09");
21463                                    assert(ios.width() == 0);
21464                                }
21465                                ios.width(25);
21466                                internal(ios);
21467                                {
21468                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21469                                    std::string ex(str, iter.base());
21470                                    assert(ex == "******************1.2e+09");
21471                                    assert(ios.width() == 0);
21472                                }
21473                            }
21474                            ios.imbue(lg);
21475                            {
21476                                ios.width(0);
21477                                {
21478                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21479                                    std::string ex(str, iter.base());
21480                                    assert(ex == "1;2e+09");
21481                                    assert(ios.width() == 0);
21482                                }
21483                                ios.width(25);
21484                                left(ios);
21485                                {
21486                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21487                                    std::string ex(str, iter.base());
21488                                    assert(ex == "1;2e+09******************");
21489                                    assert(ios.width() == 0);
21490                                }
21491                                ios.width(25);
21492                                right(ios);
21493                                {
21494                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21495                                    std::string ex(str, iter.base());
21496                                    assert(ex == "******************1;2e+09");
21497                                    assert(ios.width() == 0);
21498                                }
21499                                ios.width(25);
21500                                internal(ios);
21501                                {
21502                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21503                                    std::string ex(str, iter.base());
21504                                    assert(ex == "******************1;2e+09");
21505                                    assert(ios.width() == 0);
21506                                }
21507                            }
21508                        }
21509                        showpoint(ios);
21510                        {
21511                            ios.imbue(lc);
21512                            {
21513                                ios.width(0);
21514                                {
21515                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21516                                    std::string ex(str, iter.base());
21517                                    assert(ex == "1.2e+09");
21518                                    assert(ios.width() == 0);
21519                                }
21520                                ios.width(25);
21521                                left(ios);
21522                                {
21523                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21524                                    std::string ex(str, iter.base());
21525                                    assert(ex == "1.2e+09******************");
21526                                    assert(ios.width() == 0);
21527                                }
21528                                ios.width(25);
21529                                right(ios);
21530                                {
21531                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21532                                    std::string ex(str, iter.base());
21533                                    assert(ex == "******************1.2e+09");
21534                                    assert(ios.width() == 0);
21535                                }
21536                                ios.width(25);
21537                                internal(ios);
21538                                {
21539                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21540                                    std::string ex(str, iter.base());
21541                                    assert(ex == "******************1.2e+09");
21542                                    assert(ios.width() == 0);
21543                                }
21544                            }
21545                            ios.imbue(lg);
21546                            {
21547                                ios.width(0);
21548                                {
21549                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21550                                    std::string ex(str, iter.base());
21551                                    assert(ex == "1;2e+09");
21552                                    assert(ios.width() == 0);
21553                                }
21554                                ios.width(25);
21555                                left(ios);
21556                                {
21557                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21558                                    std::string ex(str, iter.base());
21559                                    assert(ex == "1;2e+09******************");
21560                                    assert(ios.width() == 0);
21561                                }
21562                                ios.width(25);
21563                                right(ios);
21564                                {
21565                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21566                                    std::string ex(str, iter.base());
21567                                    assert(ex == "******************1;2e+09");
21568                                    assert(ios.width() == 0);
21569                                }
21570                                ios.width(25);
21571                                internal(ios);
21572                                {
21573                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21574                                    std::string ex(str, iter.base());
21575                                    assert(ex == "******************1;2e+09");
21576                                    assert(ios.width() == 0);
21577                                }
21578                            }
21579                        }
21580                    }
21581                    showpos(ios);
21582                    {
21583                        noshowpoint(ios);
21584                        {
21585                            ios.imbue(lc);
21586                            {
21587                                ios.width(0);
21588                                {
21589                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21590                                    std::string ex(str, iter.base());
21591                                    assert(ex == "+1.2e+09");
21592                                    assert(ios.width() == 0);
21593                                }
21594                                ios.width(25);
21595                                left(ios);
21596                                {
21597                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21598                                    std::string ex(str, iter.base());
21599                                    assert(ex == "+1.2e+09*****************");
21600                                    assert(ios.width() == 0);
21601                                }
21602                                ios.width(25);
21603                                right(ios);
21604                                {
21605                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21606                                    std::string ex(str, iter.base());
21607                                    assert(ex == "*****************+1.2e+09");
21608                                    assert(ios.width() == 0);
21609                                }
21610                                ios.width(25);
21611                                internal(ios);
21612                                {
21613                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21614                                    std::string ex(str, iter.base());
21615                                    assert(ex == "+*****************1.2e+09");
21616                                    assert(ios.width() == 0);
21617                                }
21618                            }
21619                            ios.imbue(lg);
21620                            {
21621                                ios.width(0);
21622                                {
21623                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21624                                    std::string ex(str, iter.base());
21625                                    assert(ex == "+1;2e+09");
21626                                    assert(ios.width() == 0);
21627                                }
21628                                ios.width(25);
21629                                left(ios);
21630                                {
21631                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21632                                    std::string ex(str, iter.base());
21633                                    assert(ex == "+1;2e+09*****************");
21634                                    assert(ios.width() == 0);
21635                                }
21636                                ios.width(25);
21637                                right(ios);
21638                                {
21639                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21640                                    std::string ex(str, iter.base());
21641                                    assert(ex == "*****************+1;2e+09");
21642                                    assert(ios.width() == 0);
21643                                }
21644                                ios.width(25);
21645                                internal(ios);
21646                                {
21647                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21648                                    std::string ex(str, iter.base());
21649                                    assert(ex == "+*****************1;2e+09");
21650                                    assert(ios.width() == 0);
21651                                }
21652                            }
21653                        }
21654                        showpoint(ios);
21655                        {
21656                            ios.imbue(lc);
21657                            {
21658                                ios.width(0);
21659                                {
21660                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21661                                    std::string ex(str, iter.base());
21662                                    assert(ex == "+1.2e+09");
21663                                    assert(ios.width() == 0);
21664                                }
21665                                ios.width(25);
21666                                left(ios);
21667                                {
21668                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21669                                    std::string ex(str, iter.base());
21670                                    assert(ex == "+1.2e+09*****************");
21671                                    assert(ios.width() == 0);
21672                                }
21673                                ios.width(25);
21674                                right(ios);
21675                                {
21676                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21677                                    std::string ex(str, iter.base());
21678                                    assert(ex == "*****************+1.2e+09");
21679                                    assert(ios.width() == 0);
21680                                }
21681                                ios.width(25);
21682                                internal(ios);
21683                                {
21684                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21685                                    std::string ex(str, iter.base());
21686                                    assert(ex == "+*****************1.2e+09");
21687                                    assert(ios.width() == 0);
21688                                }
21689                            }
21690                            ios.imbue(lg);
21691                            {
21692                                ios.width(0);
21693                                {
21694                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21695                                    std::string ex(str, iter.base());
21696                                    assert(ex == "+1;2e+09");
21697                                    assert(ios.width() == 0);
21698                                }
21699                                ios.width(25);
21700                                left(ios);
21701                                {
21702                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21703                                    std::string ex(str, iter.base());
21704                                    assert(ex == "+1;2e+09*****************");
21705                                    assert(ios.width() == 0);
21706                                }
21707                                ios.width(25);
21708                                right(ios);
21709                                {
21710                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21711                                    std::string ex(str, iter.base());
21712                                    assert(ex == "*****************+1;2e+09");
21713                                    assert(ios.width() == 0);
21714                                }
21715                                ios.width(25);
21716                                internal(ios);
21717                                {
21718                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21719                                    std::string ex(str, iter.base());
21720                                    assert(ex == "+*****************1;2e+09");
21721                                    assert(ios.width() == 0);
21722                                }
21723                            }
21724                        }
21725                    }
21726                }
21727                uppercase(ios);
21728                {
21729                    noshowpos(ios);
21730                    {
21731                        noshowpoint(ios);
21732                        {
21733                            ios.imbue(lc);
21734                            {
21735                                ios.width(0);
21736                                {
21737                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21738                                    std::string ex(str, iter.base());
21739                                    assert(ex == "1.2E+09");
21740                                    assert(ios.width() == 0);
21741                                }
21742                                ios.width(25);
21743                                left(ios);
21744                                {
21745                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21746                                    std::string ex(str, iter.base());
21747                                    assert(ex == "1.2E+09******************");
21748                                    assert(ios.width() == 0);
21749                                }
21750                                ios.width(25);
21751                                right(ios);
21752                                {
21753                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21754                                    std::string ex(str, iter.base());
21755                                    assert(ex == "******************1.2E+09");
21756                                    assert(ios.width() == 0);
21757                                }
21758                                ios.width(25);
21759                                internal(ios);
21760                                {
21761                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21762                                    std::string ex(str, iter.base());
21763                                    assert(ex == "******************1.2E+09");
21764                                    assert(ios.width() == 0);
21765                                }
21766                            }
21767                            ios.imbue(lg);
21768                            {
21769                                ios.width(0);
21770                                {
21771                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21772                                    std::string ex(str, iter.base());
21773                                    assert(ex == "1;2E+09");
21774                                    assert(ios.width() == 0);
21775                                }
21776                                ios.width(25);
21777                                left(ios);
21778                                {
21779                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21780                                    std::string ex(str, iter.base());
21781                                    assert(ex == "1;2E+09******************");
21782                                    assert(ios.width() == 0);
21783                                }
21784                                ios.width(25);
21785                                right(ios);
21786                                {
21787                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21788                                    std::string ex(str, iter.base());
21789                                    assert(ex == "******************1;2E+09");
21790                                    assert(ios.width() == 0);
21791                                }
21792                                ios.width(25);
21793                                internal(ios);
21794                                {
21795                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21796                                    std::string ex(str, iter.base());
21797                                    assert(ex == "******************1;2E+09");
21798                                    assert(ios.width() == 0);
21799                                }
21800                            }
21801                        }
21802                        showpoint(ios);
21803                        {
21804                            ios.imbue(lc);
21805                            {
21806                                ios.width(0);
21807                                {
21808                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21809                                    std::string ex(str, iter.base());
21810                                    assert(ex == "1.2E+09");
21811                                    assert(ios.width() == 0);
21812                                }
21813                                ios.width(25);
21814                                left(ios);
21815                                {
21816                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21817                                    std::string ex(str, iter.base());
21818                                    assert(ex == "1.2E+09******************");
21819                                    assert(ios.width() == 0);
21820                                }
21821                                ios.width(25);
21822                                right(ios);
21823                                {
21824                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21825                                    std::string ex(str, iter.base());
21826                                    assert(ex == "******************1.2E+09");
21827                                    assert(ios.width() == 0);
21828                                }
21829                                ios.width(25);
21830                                internal(ios);
21831                                {
21832                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21833                                    std::string ex(str, iter.base());
21834                                    assert(ex == "******************1.2E+09");
21835                                    assert(ios.width() == 0);
21836                                }
21837                            }
21838                            ios.imbue(lg);
21839                            {
21840                                ios.width(0);
21841                                {
21842                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21843                                    std::string ex(str, iter.base());
21844                                    assert(ex == "1;2E+09");
21845                                    assert(ios.width() == 0);
21846                                }
21847                                ios.width(25);
21848                                left(ios);
21849                                {
21850                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21851                                    std::string ex(str, iter.base());
21852                                    assert(ex == "1;2E+09******************");
21853                                    assert(ios.width() == 0);
21854                                }
21855                                ios.width(25);
21856                                right(ios);
21857                                {
21858                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21859                                    std::string ex(str, iter.base());
21860                                    assert(ex == "******************1;2E+09");
21861                                    assert(ios.width() == 0);
21862                                }
21863                                ios.width(25);
21864                                internal(ios);
21865                                {
21866                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21867                                    std::string ex(str, iter.base());
21868                                    assert(ex == "******************1;2E+09");
21869                                    assert(ios.width() == 0);
21870                                }
21871                            }
21872                        }
21873                    }
21874                    showpos(ios);
21875                    {
21876                        noshowpoint(ios);
21877                        {
21878                            ios.imbue(lc);
21879                            {
21880                                ios.width(0);
21881                                {
21882                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21883                                    std::string ex(str, iter.base());
21884                                    assert(ex == "+1.2E+09");
21885                                    assert(ios.width() == 0);
21886                                }
21887                                ios.width(25);
21888                                left(ios);
21889                                {
21890                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21891                                    std::string ex(str, iter.base());
21892                                    assert(ex == "+1.2E+09*****************");
21893                                    assert(ios.width() == 0);
21894                                }
21895                                ios.width(25);
21896                                right(ios);
21897                                {
21898                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21899                                    std::string ex(str, iter.base());
21900                                    assert(ex == "*****************+1.2E+09");
21901                                    assert(ios.width() == 0);
21902                                }
21903                                ios.width(25);
21904                                internal(ios);
21905                                {
21906                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21907                                    std::string ex(str, iter.base());
21908                                    assert(ex == "+*****************1.2E+09");
21909                                    assert(ios.width() == 0);
21910                                }
21911                            }
21912                            ios.imbue(lg);
21913                            {
21914                                ios.width(0);
21915                                {
21916                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21917                                    std::string ex(str, iter.base());
21918                                    assert(ex == "+1;2E+09");
21919                                    assert(ios.width() == 0);
21920                                }
21921                                ios.width(25);
21922                                left(ios);
21923                                {
21924                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21925                                    std::string ex(str, iter.base());
21926                                    assert(ex == "+1;2E+09*****************");
21927                                    assert(ios.width() == 0);
21928                                }
21929                                ios.width(25);
21930                                right(ios);
21931                                {
21932                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21933                                    std::string ex(str, iter.base());
21934                                    assert(ex == "*****************+1;2E+09");
21935                                    assert(ios.width() == 0);
21936                                }
21937                                ios.width(25);
21938                                internal(ios);
21939                                {
21940                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21941                                    std::string ex(str, iter.base());
21942                                    assert(ex == "+*****************1;2E+09");
21943                                    assert(ios.width() == 0);
21944                                }
21945                            }
21946                        }
21947                        showpoint(ios);
21948                        {
21949                            ios.imbue(lc);
21950                            {
21951                                ios.width(0);
21952                                {
21953                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21954                                    std::string ex(str, iter.base());
21955                                    assert(ex == "+1.2E+09");
21956                                    assert(ios.width() == 0);
21957                                }
21958                                ios.width(25);
21959                                left(ios);
21960                                {
21961                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21962                                    std::string ex(str, iter.base());
21963                                    assert(ex == "+1.2E+09*****************");
21964                                    assert(ios.width() == 0);
21965                                }
21966                                ios.width(25);
21967                                right(ios);
21968                                {
21969                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21970                                    std::string ex(str, iter.base());
21971                                    assert(ex == "*****************+1.2E+09");
21972                                    assert(ios.width() == 0);
21973                                }
21974                                ios.width(25);
21975                                internal(ios);
21976                                {
21977                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21978                                    std::string ex(str, iter.base());
21979                                    assert(ex == "+*****************1.2E+09");
21980                                    assert(ios.width() == 0);
21981                                }
21982                            }
21983                            ios.imbue(lg);
21984                            {
21985                                ios.width(0);
21986                                {
21987                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21988                                    std::string ex(str, iter.base());
21989                                    assert(ex == "+1;2E+09");
21990                                    assert(ios.width() == 0);
21991                                }
21992                                ios.width(25);
21993                                left(ios);
21994                                {
21995                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
21996                                    std::string ex(str, iter.base());
21997                                    assert(ex == "+1;2E+09*****************");
21998                                    assert(ios.width() == 0);
21999                                }
22000                                ios.width(25);
22001                                right(ios);
22002                                {
22003                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22004                                    std::string ex(str, iter.base());
22005                                    assert(ex == "*****************+1;2E+09");
22006                                    assert(ios.width() == 0);
22007                                }
22008                                ios.width(25);
22009                                internal(ios);
22010                                {
22011                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22012                                    std::string ex(str, iter.base());
22013                                    assert(ex == "+*****************1;2E+09");
22014                                    assert(ios.width() == 0);
22015                                }
22016                            }
22017                        }
22018                    }
22019                }
22020            }
22021            ios.precision(6);
22022            {
22023            }
22024            ios.precision(16);
22025            {
22026            }
22027            ios.precision(60);
22028            {
22029                nouppercase(ios);
22030                {
22031                    noshowpos(ios);
22032                    {
22033                        noshowpoint(ios);
22034                        {
22035                            ios.imbue(lc);
22036                            {
22037                                ios.width(0);
22038                                {
22039                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22040                                    std::string ex(str, iter.base());
22041                                    assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22042                                    assert(ios.width() == 0);
22043                                }
22044                                ios.width(25);
22045                                left(ios);
22046                                {
22047                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22048                                    std::string ex(str, iter.base());
22049                                    assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22050                                    assert(ios.width() == 0);
22051                                }
22052                                ios.width(25);
22053                                right(ios);
22054                                {
22055                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22056                                    std::string ex(str, iter.base());
22057                                    assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22058                                    assert(ios.width() == 0);
22059                                }
22060                                ios.width(25);
22061                                internal(ios);
22062                                {
22063                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22064                                    std::string ex(str, iter.base());
22065                                    assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22066                                    assert(ios.width() == 0);
22067                                }
22068                            }
22069                            ios.imbue(lg);
22070                            {
22071                                ios.width(0);
22072                                {
22073                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22074                                    std::string ex(str, iter.base());
22075                                    assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22076                                    assert(ios.width() == 0);
22077                                }
22078                                ios.width(25);
22079                                left(ios);
22080                                {
22081                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22082                                    std::string ex(str, iter.base());
22083                                    assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22084                                    assert(ios.width() == 0);
22085                                }
22086                                ios.width(25);
22087                                right(ios);
22088                                {
22089                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22090                                    std::string ex(str, iter.base());
22091                                    assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22092                                    assert(ios.width() == 0);
22093                                }
22094                                ios.width(25);
22095                                internal(ios);
22096                                {
22097                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22098                                    std::string ex(str, iter.base());
22099                                    assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22100                                    assert(ios.width() == 0);
22101                                }
22102                            }
22103                        }
22104                        showpoint(ios);
22105                        {
22106                            ios.imbue(lc);
22107                            {
22108                                ios.width(0);
22109                                {
22110                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22111                                    std::string ex(str, iter.base());
22112                                    assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22113                                    assert(ios.width() == 0);
22114                                }
22115                                ios.width(25);
22116                                left(ios);
22117                                {
22118                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22119                                    std::string ex(str, iter.base());
22120                                    assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22121                                    assert(ios.width() == 0);
22122                                }
22123                                ios.width(25);
22124                                right(ios);
22125                                {
22126                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22127                                    std::string ex(str, iter.base());
22128                                    assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22129                                    assert(ios.width() == 0);
22130                                }
22131                                ios.width(25);
22132                                internal(ios);
22133                                {
22134                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22135                                    std::string ex(str, iter.base());
22136                                    assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
22137                                    assert(ios.width() == 0);
22138                                }
22139                            }
22140                            ios.imbue(lg);
22141                            {
22142                                ios.width(0);
22143                                {
22144                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22145                                    std::string ex(str, iter.base());
22146                                    assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22147                                    assert(ios.width() == 0);
22148                                }
22149                                ios.width(25);
22150                                left(ios);
22151                                {
22152                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22153                                    std::string ex(str, iter.base());
22154                                    assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22155                                    assert(ios.width() == 0);
22156                                }
22157                                ios.width(25);
22158                                right(ios);
22159                                {
22160                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22161                                    std::string ex(str, iter.base());
22162                                    assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22163                                    assert(ios.width() == 0);
22164                                }
22165                                ios.width(25);
22166                                internal(ios);
22167                                {
22168                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22169                                    std::string ex(str, iter.base());
22170                                    assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
22171                                    assert(ios.width() == 0);
22172                                }
22173                            }
22174                        }
22175                    }
22176                    showpos(ios);
22177                    {
22178                        noshowpoint(ios);
22179                        {
22180                            ios.imbue(lc);
22181                            {
22182                                ios.width(0);
22183                                {
22184                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22185                                    std::string ex(str, iter.base());
22186                                    assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22187                                    assert(ios.width() == 0);
22188                                }
22189                                ios.width(25);
22190                                left(ios);
22191                                {
22192                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22193                                    std::string ex(str, iter.base());
22194                                    assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22195                                    assert(ios.width() == 0);
22196                                }
22197                                ios.width(25);
22198                                right(ios);
22199                                {
22200                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22201                                    std::string ex(str, iter.base());
22202                                    assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22203                                    assert(ios.width() == 0);
22204                                }
22205                                ios.width(25);
22206                                internal(ios);
22207                                {
22208                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22209                                    std::string ex(str, iter.base());
22210                                    assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22211                                    assert(ios.width() == 0);
22212                                }
22213                            }
22214                            ios.imbue(lg);
22215                            {
22216                                ios.width(0);
22217                                {
22218                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22219                                    std::string ex(str, iter.base());
22220                                    assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22221                                    assert(ios.width() == 0);
22222                                }
22223                                ios.width(25);
22224                                left(ios);
22225                                {
22226                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22227                                    std::string ex(str, iter.base());
22228                                    assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22229                                    assert(ios.width() == 0);
22230                                }
22231                                ios.width(25);
22232                                right(ios);
22233                                {
22234                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22235                                    std::string ex(str, iter.base());
22236                                    assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22237                                    assert(ios.width() == 0);
22238                                }
22239                                ios.width(25);
22240                                internal(ios);
22241                                {
22242                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22243                                    std::string ex(str, iter.base());
22244                                    assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22245                                    assert(ios.width() == 0);
22246                                }
22247                            }
22248                        }
22249                        showpoint(ios);
22250                        {
22251                            ios.imbue(lc);
22252                            {
22253                                ios.width(0);
22254                                {
22255                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22256                                    std::string ex(str, iter.base());
22257                                    assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22258                                    assert(ios.width() == 0);
22259                                }
22260                                ios.width(25);
22261                                left(ios);
22262                                {
22263                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22264                                    std::string ex(str, iter.base());
22265                                    assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22266                                    assert(ios.width() == 0);
22267                                }
22268                                ios.width(25);
22269                                right(ios);
22270                                {
22271                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22272                                    std::string ex(str, iter.base());
22273                                    assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22274                                    assert(ios.width() == 0);
22275                                }
22276                                ios.width(25);
22277                                internal(ios);
22278                                {
22279                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22280                                    std::string ex(str, iter.base());
22281                                    assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
22282                                    assert(ios.width() == 0);
22283                                }
22284                            }
22285                            ios.imbue(lg);
22286                            {
22287                                ios.width(0);
22288                                {
22289                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22290                                    std::string ex(str, iter.base());
22291                                    assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22292                                    assert(ios.width() == 0);
22293                                }
22294                                ios.width(25);
22295                                left(ios);
22296                                {
22297                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22298                                    std::string ex(str, iter.base());
22299                                    assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22300                                    assert(ios.width() == 0);
22301                                }
22302                                ios.width(25);
22303                                right(ios);
22304                                {
22305                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22306                                    std::string ex(str, iter.base());
22307                                    assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22308                                    assert(ios.width() == 0);
22309                                }
22310                                ios.width(25);
22311                                internal(ios);
22312                                {
22313                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22314                                    std::string ex(str, iter.base());
22315                                    assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
22316                                    assert(ios.width() == 0);
22317                                }
22318                            }
22319                        }
22320                    }
22321                }
22322                uppercase(ios);
22323                {
22324                    noshowpos(ios);
22325                    {
22326                        noshowpoint(ios);
22327                        {
22328                            ios.imbue(lc);
22329                            {
22330                                ios.width(0);
22331                                {
22332                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22333                                    std::string ex(str, iter.base());
22334                                    assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22335                                    assert(ios.width() == 0);
22336                                }
22337                                ios.width(25);
22338                                left(ios);
22339                                {
22340                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22341                                    std::string ex(str, iter.base());
22342                                    assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22343                                    assert(ios.width() == 0);
22344                                }
22345                                ios.width(25);
22346                                right(ios);
22347                                {
22348                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22349                                    std::string ex(str, iter.base());
22350                                    assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22351                                    assert(ios.width() == 0);
22352                                }
22353                                ios.width(25);
22354                                internal(ios);
22355                                {
22356                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22357                                    std::string ex(str, iter.base());
22358                                    assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22359                                    assert(ios.width() == 0);
22360                                }
22361                            }
22362                            ios.imbue(lg);
22363                            {
22364                                ios.width(0);
22365                                {
22366                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22367                                    std::string ex(str, iter.base());
22368                                    assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22369                                    assert(ios.width() == 0);
22370                                }
22371                                ios.width(25);
22372                                left(ios);
22373                                {
22374                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22375                                    std::string ex(str, iter.base());
22376                                    assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22377                                    assert(ios.width() == 0);
22378                                }
22379                                ios.width(25);
22380                                right(ios);
22381                                {
22382                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22383                                    std::string ex(str, iter.base());
22384                                    assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22385                                    assert(ios.width() == 0);
22386                                }
22387                                ios.width(25);
22388                                internal(ios);
22389                                {
22390                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22391                                    std::string ex(str, iter.base());
22392                                    assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22393                                    assert(ios.width() == 0);
22394                                }
22395                            }
22396                        }
22397                        showpoint(ios);
22398                        {
22399                            ios.imbue(lc);
22400                            {
22401                                ios.width(0);
22402                                {
22403                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22404                                    std::string ex(str, iter.base());
22405                                    assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22406                                    assert(ios.width() == 0);
22407                                }
22408                                ios.width(25);
22409                                left(ios);
22410                                {
22411                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22412                                    std::string ex(str, iter.base());
22413                                    assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22414                                    assert(ios.width() == 0);
22415                                }
22416                                ios.width(25);
22417                                right(ios);
22418                                {
22419                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22420                                    std::string ex(str, iter.base());
22421                                    assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22422                                    assert(ios.width() == 0);
22423                                }
22424                                ios.width(25);
22425                                internal(ios);
22426                                {
22427                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22428                                    std::string ex(str, iter.base());
22429                                    assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
22430                                    assert(ios.width() == 0);
22431                                }
22432                            }
22433                            ios.imbue(lg);
22434                            {
22435                                ios.width(0);
22436                                {
22437                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22438                                    std::string ex(str, iter.base());
22439                                    assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22440                                    assert(ios.width() == 0);
22441                                }
22442                                ios.width(25);
22443                                left(ios);
22444                                {
22445                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22446                                    std::string ex(str, iter.base());
22447                                    assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22448                                    assert(ios.width() == 0);
22449                                }
22450                                ios.width(25);
22451                                right(ios);
22452                                {
22453                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22454                                    std::string ex(str, iter.base());
22455                                    assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22456                                    assert(ios.width() == 0);
22457                                }
22458                                ios.width(25);
22459                                internal(ios);
22460                                {
22461                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22462                                    std::string ex(str, iter.base());
22463                                    assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
22464                                    assert(ios.width() == 0);
22465                                }
22466                            }
22467                        }
22468                    }
22469                    showpos(ios);
22470                    {
22471                        noshowpoint(ios);
22472                        {
22473                            ios.imbue(lc);
22474                            {
22475                                ios.width(0);
22476                                {
22477                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22478                                    std::string ex(str, iter.base());
22479                                    assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22480                                    assert(ios.width() == 0);
22481                                }
22482                                ios.width(25);
22483                                left(ios);
22484                                {
22485                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22486                                    std::string ex(str, iter.base());
22487                                    assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22488                                    assert(ios.width() == 0);
22489                                }
22490                                ios.width(25);
22491                                right(ios);
22492                                {
22493                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22494                                    std::string ex(str, iter.base());
22495                                    assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22496                                    assert(ios.width() == 0);
22497                                }
22498                                ios.width(25);
22499                                internal(ios);
22500                                {
22501                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22502                                    std::string ex(str, iter.base());
22503                                    assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22504                                    assert(ios.width() == 0);
22505                                }
22506                            }
22507                            ios.imbue(lg);
22508                            {
22509                                ios.width(0);
22510                                {
22511                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22512                                    std::string ex(str, iter.base());
22513                                    assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22514                                    assert(ios.width() == 0);
22515                                }
22516                                ios.width(25);
22517                                left(ios);
22518                                {
22519                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22520                                    std::string ex(str, iter.base());
22521                                    assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22522                                    assert(ios.width() == 0);
22523                                }
22524                                ios.width(25);
22525                                right(ios);
22526                                {
22527                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22528                                    std::string ex(str, iter.base());
22529                                    assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22530                                    assert(ios.width() == 0);
22531                                }
22532                                ios.width(25);
22533                                internal(ios);
22534                                {
22535                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22536                                    std::string ex(str, iter.base());
22537                                    assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22538                                    assert(ios.width() == 0);
22539                                }
22540                            }
22541                        }
22542                        showpoint(ios);
22543                        {
22544                            ios.imbue(lc);
22545                            {
22546                                ios.width(0);
22547                                {
22548                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22549                                    std::string ex(str, iter.base());
22550                                    assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22551                                    assert(ios.width() == 0);
22552                                }
22553                                ios.width(25);
22554                                left(ios);
22555                                {
22556                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22557                                    std::string ex(str, iter.base());
22558                                    assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22559                                    assert(ios.width() == 0);
22560                                }
22561                                ios.width(25);
22562                                right(ios);
22563                                {
22564                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22565                                    std::string ex(str, iter.base());
22566                                    assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22567                                    assert(ios.width() == 0);
22568                                }
22569                                ios.width(25);
22570                                internal(ios);
22571                                {
22572                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22573                                    std::string ex(str, iter.base());
22574                                    assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
22575                                    assert(ios.width() == 0);
22576                                }
22577                            }
22578                            ios.imbue(lg);
22579                            {
22580                                ios.width(0);
22581                                {
22582                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22583                                    std::string ex(str, iter.base());
22584                                    assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22585                                    assert(ios.width() == 0);
22586                                }
22587                                ios.width(25);
22588                                left(ios);
22589                                {
22590                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22591                                    std::string ex(str, iter.base());
22592                                    assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22593                                    assert(ios.width() == 0);
22594                                }
22595                                ios.width(25);
22596                                right(ios);
22597                                {
22598                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22599                                    std::string ex(str, iter.base());
22600                                    assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22601                                    assert(ios.width() == 0);
22602                                }
22603                                ios.width(25);
22604                                internal(ios);
22605                                {
22606                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22607                                    std::string ex(str, iter.base());
22608                                    assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
22609                                    assert(ios.width() == 0);
22610                                }
22611                            }
22612                        }
22613                    }
22614                }
22615            }
22616        }
22617    }
22618}
22619
22620void test11()
22621{
22622    char str[200];
22623    output_iterator<char*> iter;
22624    std::locale lc = std::locale::classic();
22625    std::locale lg(lc, new my_numpunct);
22626    const my_facet f(1);
22627    {
22628        long double v = -0.;
22629        std::ios ios(0);
22630        hexfloat(ios);
22631        // %a
22632        {
22633            ios.precision(0);
22634            {
22635                nouppercase(ios);
22636                {
22637                    noshowpos(ios);
22638                    {
22639                        noshowpoint(ios);
22640                        {
22641                            ios.imbue(lc);
22642                            {
22643                                ios.width(0);
22644                                {
22645                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22646                                    std::string ex(str, iter.base());
22647                                    assert(ex == "-0x0p+0");
22648                                    assert(ios.width() == 0);
22649                                }
22650                                ios.width(25);
22651                                left(ios);
22652                                {
22653                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22654                                    std::string ex(str, iter.base());
22655                                    assert(ex == "-0x0p+0******************");
22656                                    assert(ios.width() == 0);
22657                                }
22658                                ios.width(25);
22659                                right(ios);
22660                                {
22661                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22662                                    std::string ex(str, iter.base());
22663                                    assert(ex == "******************-0x0p+0");
22664                                    assert(ios.width() == 0);
22665                                }
22666                                ios.width(25);
22667                                internal(ios);
22668                                {
22669                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22670                                    std::string ex(str, iter.base());
22671                                    assert(ex == "-******************0x0p+0");
22672                                    assert(ios.width() == 0);
22673                                }
22674                            }
22675                            ios.imbue(lg);
22676                            {
22677                                ios.width(0);
22678                                {
22679                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22680                                    std::string ex(str, iter.base());
22681                                    assert(ex == "-0x0p+0");
22682                                    assert(ios.width() == 0);
22683                                }
22684                                ios.width(25);
22685                                left(ios);
22686                                {
22687                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22688                                    std::string ex(str, iter.base());
22689                                    assert(ex == "-0x0p+0******************");
22690                                    assert(ios.width() == 0);
22691                                }
22692                                ios.width(25);
22693                                right(ios);
22694                                {
22695                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22696                                    std::string ex(str, iter.base());
22697                                    assert(ex == "******************-0x0p+0");
22698                                    assert(ios.width() == 0);
22699                                }
22700                                ios.width(25);
22701                                internal(ios);
22702                                {
22703                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22704                                    std::string ex(str, iter.base());
22705                                    assert(ex == "-******************0x0p+0");
22706                                    assert(ios.width() == 0);
22707                                }
22708                            }
22709                        }
22710                        showpoint(ios);
22711                        {
22712                            ios.imbue(lc);
22713                            {
22714                                ios.width(0);
22715                                {
22716                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22717                                    std::string ex(str, iter.base());
22718                                    assert(ex == "-0x0.p+0");
22719                                    assert(ios.width() == 0);
22720                                }
22721                                ios.width(25);
22722                                left(ios);
22723                                {
22724                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22725                                    std::string ex(str, iter.base());
22726                                    assert(ex == "-0x0.p+0*****************");
22727                                    assert(ios.width() == 0);
22728                                }
22729                                ios.width(25);
22730                                right(ios);
22731                                {
22732                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22733                                    std::string ex(str, iter.base());
22734                                    assert(ex == "*****************-0x0.p+0");
22735                                    assert(ios.width() == 0);
22736                                }
22737                                ios.width(25);
22738                                internal(ios);
22739                                {
22740                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22741                                    std::string ex(str, iter.base());
22742                                    assert(ex == "-*****************0x0.p+0");
22743                                    assert(ios.width() == 0);
22744                                }
22745                            }
22746                            ios.imbue(lg);
22747                            {
22748                                ios.width(0);
22749                                {
22750                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22751                                    std::string ex(str, iter.base());
22752                                    assert(ex == "-0x0;p+0");
22753                                    assert(ios.width() == 0);
22754                                }
22755                                ios.width(25);
22756                                left(ios);
22757                                {
22758                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22759                                    std::string ex(str, iter.base());
22760                                    assert(ex == "-0x0;p+0*****************");
22761                                    assert(ios.width() == 0);
22762                                }
22763                                ios.width(25);
22764                                right(ios);
22765                                {
22766                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22767                                    std::string ex(str, iter.base());
22768                                    assert(ex == "*****************-0x0;p+0");
22769                                    assert(ios.width() == 0);
22770                                }
22771                                ios.width(25);
22772                                internal(ios);
22773                                {
22774                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22775                                    std::string ex(str, iter.base());
22776                                    assert(ex == "-*****************0x0;p+0");
22777                                    assert(ios.width() == 0);
22778                                }
22779                            }
22780                        }
22781                    }
22782                    showpos(ios);
22783                    {
22784                        noshowpoint(ios);
22785                        {
22786                            ios.imbue(lc);
22787                            {
22788                                ios.width(0);
22789                                {
22790                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22791                                    std::string ex(str, iter.base());
22792                                    assert(ex == "-0x0p+0");
22793                                    assert(ios.width() == 0);
22794                                }
22795                                ios.width(25);
22796                                left(ios);
22797                                {
22798                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22799                                    std::string ex(str, iter.base());
22800                                    assert(ex == "-0x0p+0******************");
22801                                    assert(ios.width() == 0);
22802                                }
22803                                ios.width(25);
22804                                right(ios);
22805                                {
22806                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22807                                    std::string ex(str, iter.base());
22808                                    assert(ex == "******************-0x0p+0");
22809                                    assert(ios.width() == 0);
22810                                }
22811                                ios.width(25);
22812                                internal(ios);
22813                                {
22814                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22815                                    std::string ex(str, iter.base());
22816                                    assert(ex == "-******************0x0p+0");
22817                                    assert(ios.width() == 0);
22818                                }
22819                            }
22820                            ios.imbue(lg);
22821                            {
22822                                ios.width(0);
22823                                {
22824                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22825                                    std::string ex(str, iter.base());
22826                                    assert(ex == "-0x0p+0");
22827                                    assert(ios.width() == 0);
22828                                }
22829                                ios.width(25);
22830                                left(ios);
22831                                {
22832                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22833                                    std::string ex(str, iter.base());
22834                                    assert(ex == "-0x0p+0******************");
22835                                    assert(ios.width() == 0);
22836                                }
22837                                ios.width(25);
22838                                right(ios);
22839                                {
22840                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22841                                    std::string ex(str, iter.base());
22842                                    assert(ex == "******************-0x0p+0");
22843                                    assert(ios.width() == 0);
22844                                }
22845                                ios.width(25);
22846                                internal(ios);
22847                                {
22848                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22849                                    std::string ex(str, iter.base());
22850                                    assert(ex == "-******************0x0p+0");
22851                                    assert(ios.width() == 0);
22852                                }
22853                            }
22854                        }
22855                        showpoint(ios);
22856                        {
22857                            ios.imbue(lc);
22858                            {
22859                                ios.width(0);
22860                                {
22861                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22862                                    std::string ex(str, iter.base());
22863                                    assert(ex == "-0x0.p+0");
22864                                    assert(ios.width() == 0);
22865                                }
22866                                ios.width(25);
22867                                left(ios);
22868                                {
22869                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22870                                    std::string ex(str, iter.base());
22871                                    assert(ex == "-0x0.p+0*****************");
22872                                    assert(ios.width() == 0);
22873                                }
22874                                ios.width(25);
22875                                right(ios);
22876                                {
22877                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22878                                    std::string ex(str, iter.base());
22879                                    assert(ex == "*****************-0x0.p+0");
22880                                    assert(ios.width() == 0);
22881                                }
22882                                ios.width(25);
22883                                internal(ios);
22884                                {
22885                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22886                                    std::string ex(str, iter.base());
22887                                    assert(ex == "-*****************0x0.p+0");
22888                                    assert(ios.width() == 0);
22889                                }
22890                            }
22891                            ios.imbue(lg);
22892                            {
22893                                ios.width(0);
22894                                {
22895                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22896                                    std::string ex(str, iter.base());
22897                                    assert(ex == "-0x0;p+0");
22898                                    assert(ios.width() == 0);
22899                                }
22900                                ios.width(25);
22901                                left(ios);
22902                                {
22903                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22904                                    std::string ex(str, iter.base());
22905                                    assert(ex == "-0x0;p+0*****************");
22906                                    assert(ios.width() == 0);
22907                                }
22908                                ios.width(25);
22909                                right(ios);
22910                                {
22911                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22912                                    std::string ex(str, iter.base());
22913                                    assert(ex == "*****************-0x0;p+0");
22914                                    assert(ios.width() == 0);
22915                                }
22916                                ios.width(25);
22917                                internal(ios);
22918                                {
22919                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22920                                    std::string ex(str, iter.base());
22921                                    assert(ex == "-*****************0x0;p+0");
22922                                    assert(ios.width() == 0);
22923                                }
22924                            }
22925                        }
22926                    }
22927                }
22928                uppercase(ios);
22929                {
22930                    noshowpos(ios);
22931                    {
22932                        noshowpoint(ios);
22933                        {
22934                            ios.imbue(lc);
22935                            {
22936                                ios.width(0);
22937                                {
22938                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22939                                    std::string ex(str, iter.base());
22940                                    assert(ex == "-0X0P+0");
22941                                    assert(ios.width() == 0);
22942                                }
22943                                ios.width(25);
22944                                left(ios);
22945                                {
22946                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22947                                    std::string ex(str, iter.base());
22948                                    assert(ex == "-0X0P+0******************");
22949                                    assert(ios.width() == 0);
22950                                }
22951                                ios.width(25);
22952                                right(ios);
22953                                {
22954                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22955                                    std::string ex(str, iter.base());
22956                                    assert(ex == "******************-0X0P+0");
22957                                    assert(ios.width() == 0);
22958                                }
22959                                ios.width(25);
22960                                internal(ios);
22961                                {
22962                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22963                                    std::string ex(str, iter.base());
22964                                    assert(ex == "-******************0X0P+0");
22965                                    assert(ios.width() == 0);
22966                                }
22967                            }
22968                            ios.imbue(lg);
22969                            {
22970                                ios.width(0);
22971                                {
22972                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22973                                    std::string ex(str, iter.base());
22974                                    assert(ex == "-0X0P+0");
22975                                    assert(ios.width() == 0);
22976                                }
22977                                ios.width(25);
22978                                left(ios);
22979                                {
22980                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22981                                    std::string ex(str, iter.base());
22982                                    assert(ex == "-0X0P+0******************");
22983                                    assert(ios.width() == 0);
22984                                }
22985                                ios.width(25);
22986                                right(ios);
22987                                {
22988                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22989                                    std::string ex(str, iter.base());
22990                                    assert(ex == "******************-0X0P+0");
22991                                    assert(ios.width() == 0);
22992                                }
22993                                ios.width(25);
22994                                internal(ios);
22995                                {
22996                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
22997                                    std::string ex(str, iter.base());
22998                                    assert(ex == "-******************0X0P+0");
22999                                    assert(ios.width() == 0);
23000                                }
23001                            }
23002                        }
23003                        showpoint(ios);
23004                        {
23005                            ios.imbue(lc);
23006                            {
23007                                ios.width(0);
23008                                {
23009                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23010                                    std::string ex(str, iter.base());
23011                                    assert(ex == "-0X0.P+0");
23012                                    assert(ios.width() == 0);
23013                                }
23014                                ios.width(25);
23015                                left(ios);
23016                                {
23017                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23018                                    std::string ex(str, iter.base());
23019                                    assert(ex == "-0X0.P+0*****************");
23020                                    assert(ios.width() == 0);
23021                                }
23022                                ios.width(25);
23023                                right(ios);
23024                                {
23025                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23026                                    std::string ex(str, iter.base());
23027                                    assert(ex == "*****************-0X0.P+0");
23028                                    assert(ios.width() == 0);
23029                                }
23030                                ios.width(25);
23031                                internal(ios);
23032                                {
23033                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23034                                    std::string ex(str, iter.base());
23035                                    assert(ex == "-*****************0X0.P+0");
23036                                    assert(ios.width() == 0);
23037                                }
23038                            }
23039                            ios.imbue(lg);
23040                            {
23041                                ios.width(0);
23042                                {
23043                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23044                                    std::string ex(str, iter.base());
23045                                    assert(ex == "-0X0;P+0");
23046                                    assert(ios.width() == 0);
23047                                }
23048                                ios.width(25);
23049                                left(ios);
23050                                {
23051                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23052                                    std::string ex(str, iter.base());
23053                                    assert(ex == "-0X0;P+0*****************");
23054                                    assert(ios.width() == 0);
23055                                }
23056                                ios.width(25);
23057                                right(ios);
23058                                {
23059                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23060                                    std::string ex(str, iter.base());
23061                                    assert(ex == "*****************-0X0;P+0");
23062                                    assert(ios.width() == 0);
23063                                }
23064                                ios.width(25);
23065                                internal(ios);
23066                                {
23067                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23068                                    std::string ex(str, iter.base());
23069                                    assert(ex == "-*****************0X0;P+0");
23070                                    assert(ios.width() == 0);
23071                                }
23072                            }
23073                        }
23074                    }
23075                    showpos(ios);
23076                    {
23077                        noshowpoint(ios);
23078                        {
23079                            ios.imbue(lc);
23080                            {
23081                                ios.width(0);
23082                                {
23083                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23084                                    std::string ex(str, iter.base());
23085                                    assert(ex == "-0X0P+0");
23086                                    assert(ios.width() == 0);
23087                                }
23088                                ios.width(25);
23089                                left(ios);
23090                                {
23091                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23092                                    std::string ex(str, iter.base());
23093                                    assert(ex == "-0X0P+0******************");
23094                                    assert(ios.width() == 0);
23095                                }
23096                                ios.width(25);
23097                                right(ios);
23098                                {
23099                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23100                                    std::string ex(str, iter.base());
23101                                    assert(ex == "******************-0X0P+0");
23102                                    assert(ios.width() == 0);
23103                                }
23104                                ios.width(25);
23105                                internal(ios);
23106                                {
23107                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23108                                    std::string ex(str, iter.base());
23109                                    assert(ex == "-******************0X0P+0");
23110                                    assert(ios.width() == 0);
23111                                }
23112                            }
23113                            ios.imbue(lg);
23114                            {
23115                                ios.width(0);
23116                                {
23117                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23118                                    std::string ex(str, iter.base());
23119                                    assert(ex == "-0X0P+0");
23120                                    assert(ios.width() == 0);
23121                                }
23122                                ios.width(25);
23123                                left(ios);
23124                                {
23125                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23126                                    std::string ex(str, iter.base());
23127                                    assert(ex == "-0X0P+0******************");
23128                                    assert(ios.width() == 0);
23129                                }
23130                                ios.width(25);
23131                                right(ios);
23132                                {
23133                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23134                                    std::string ex(str, iter.base());
23135                                    assert(ex == "******************-0X0P+0");
23136                                    assert(ios.width() == 0);
23137                                }
23138                                ios.width(25);
23139                                internal(ios);
23140                                {
23141                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23142                                    std::string ex(str, iter.base());
23143                                    assert(ex == "-******************0X0P+0");
23144                                    assert(ios.width() == 0);
23145                                }
23146                            }
23147                        }
23148                        showpoint(ios);
23149                        {
23150                            ios.imbue(lc);
23151                            {
23152                                ios.width(0);
23153                                {
23154                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23155                                    std::string ex(str, iter.base());
23156                                    assert(ex == "-0X0.P+0");
23157                                    assert(ios.width() == 0);
23158                                }
23159                                ios.width(25);
23160                                left(ios);
23161                                {
23162                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23163                                    std::string ex(str, iter.base());
23164                                    assert(ex == "-0X0.P+0*****************");
23165                                    assert(ios.width() == 0);
23166                                }
23167                                ios.width(25);
23168                                right(ios);
23169                                {
23170                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23171                                    std::string ex(str, iter.base());
23172                                    assert(ex == "*****************-0X0.P+0");
23173                                    assert(ios.width() == 0);
23174                                }
23175                                ios.width(25);
23176                                internal(ios);
23177                                {
23178                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23179                                    std::string ex(str, iter.base());
23180                                    assert(ex == "-*****************0X0.P+0");
23181                                    assert(ios.width() == 0);
23182                                }
23183                            }
23184                            ios.imbue(lg);
23185                            {
23186                                ios.width(0);
23187                                {
23188                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23189                                    std::string ex(str, iter.base());
23190                                    assert(ex == "-0X0;P+0");
23191                                    assert(ios.width() == 0);
23192                                }
23193                                ios.width(25);
23194                                left(ios);
23195                                {
23196                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23197                                    std::string ex(str, iter.base());
23198                                    assert(ex == "-0X0;P+0*****************");
23199                                    assert(ios.width() == 0);
23200                                }
23201                                ios.width(25);
23202                                right(ios);
23203                                {
23204                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23205                                    std::string ex(str, iter.base());
23206                                    assert(ex == "*****************-0X0;P+0");
23207                                    assert(ios.width() == 0);
23208                                }
23209                                ios.width(25);
23210                                internal(ios);
23211                                {
23212                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23213                                    std::string ex(str, iter.base());
23214                                    assert(ex == "-*****************0X0;P+0");
23215                                    assert(ios.width() == 0);
23216                                }
23217                            }
23218                        }
23219                    }
23220                }
23221            }
23222            ios.precision(1);
23223            {
23224                nouppercase(ios);
23225                {
23226                    noshowpos(ios);
23227                    {
23228                        noshowpoint(ios);
23229                        {
23230                            ios.imbue(lc);
23231                            {
23232                                ios.width(0);
23233                                {
23234                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23235                                    std::string ex(str, iter.base());
23236                                    assert(ex == "-0x0p+0");
23237                                    assert(ios.width() == 0);
23238                                }
23239                                ios.width(25);
23240                                left(ios);
23241                                {
23242                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23243                                    std::string ex(str, iter.base());
23244                                    assert(ex == "-0x0p+0******************");
23245                                    assert(ios.width() == 0);
23246                                }
23247                                ios.width(25);
23248                                right(ios);
23249                                {
23250                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23251                                    std::string ex(str, iter.base());
23252                                    assert(ex == "******************-0x0p+0");
23253                                    assert(ios.width() == 0);
23254                                }
23255                                ios.width(25);
23256                                internal(ios);
23257                                {
23258                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23259                                    std::string ex(str, iter.base());
23260                                    assert(ex == "-******************0x0p+0");
23261                                    assert(ios.width() == 0);
23262                                }
23263                            }
23264                            ios.imbue(lg);
23265                            {
23266                                ios.width(0);
23267                                {
23268                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23269                                    std::string ex(str, iter.base());
23270                                    assert(ex == "-0x0p+0");
23271                                    assert(ios.width() == 0);
23272                                }
23273                                ios.width(25);
23274                                left(ios);
23275                                {
23276                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23277                                    std::string ex(str, iter.base());
23278                                    assert(ex == "-0x0p+0******************");
23279                                    assert(ios.width() == 0);
23280                                }
23281                                ios.width(25);
23282                                right(ios);
23283                                {
23284                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23285                                    std::string ex(str, iter.base());
23286                                    assert(ex == "******************-0x0p+0");
23287                                    assert(ios.width() == 0);
23288                                }
23289                                ios.width(25);
23290                                internal(ios);
23291                                {
23292                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23293                                    std::string ex(str, iter.base());
23294                                    assert(ex == "-******************0x0p+0");
23295                                    assert(ios.width() == 0);
23296                                }
23297                            }
23298                        }
23299                        showpoint(ios);
23300                        {
23301                            ios.imbue(lc);
23302                            {
23303                                ios.width(0);
23304                                {
23305                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23306                                    std::string ex(str, iter.base());
23307                                    assert(ex == "-0x0.p+0");
23308                                    assert(ios.width() == 0);
23309                                }
23310                                ios.width(25);
23311                                left(ios);
23312                                {
23313                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23314                                    std::string ex(str, iter.base());
23315                                    assert(ex == "-0x0.p+0*****************");
23316                                    assert(ios.width() == 0);
23317                                }
23318                                ios.width(25);
23319                                right(ios);
23320                                {
23321                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23322                                    std::string ex(str, iter.base());
23323                                    assert(ex == "*****************-0x0.p+0");
23324                                    assert(ios.width() == 0);
23325                                }
23326                                ios.width(25);
23327                                internal(ios);
23328                                {
23329                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23330                                    std::string ex(str, iter.base());
23331                                    assert(ex == "-*****************0x0.p+0");
23332                                    assert(ios.width() == 0);
23333                                }
23334                            }
23335                            ios.imbue(lg);
23336                            {
23337                                ios.width(0);
23338                                {
23339                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23340                                    std::string ex(str, iter.base());
23341                                    assert(ex == "-0x0;p+0");
23342                                    assert(ios.width() == 0);
23343                                }
23344                                ios.width(25);
23345                                left(ios);
23346                                {
23347                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23348                                    std::string ex(str, iter.base());
23349                                    assert(ex == "-0x0;p+0*****************");
23350                                    assert(ios.width() == 0);
23351                                }
23352                                ios.width(25);
23353                                right(ios);
23354                                {
23355                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23356                                    std::string ex(str, iter.base());
23357                                    assert(ex == "*****************-0x0;p+0");
23358                                    assert(ios.width() == 0);
23359                                }
23360                                ios.width(25);
23361                                internal(ios);
23362                                {
23363                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23364                                    std::string ex(str, iter.base());
23365                                    assert(ex == "-*****************0x0;p+0");
23366                                    assert(ios.width() == 0);
23367                                }
23368                            }
23369                        }
23370                    }
23371                    showpos(ios);
23372                    {
23373                        noshowpoint(ios);
23374                        {
23375                            ios.imbue(lc);
23376                            {
23377                                ios.width(0);
23378                                {
23379                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23380                                    std::string ex(str, iter.base());
23381                                    assert(ex == "-0x0p+0");
23382                                    assert(ios.width() == 0);
23383                                }
23384                                ios.width(25);
23385                                left(ios);
23386                                {
23387                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23388                                    std::string ex(str, iter.base());
23389                                    assert(ex == "-0x0p+0******************");
23390                                    assert(ios.width() == 0);
23391                                }
23392                                ios.width(25);
23393                                right(ios);
23394                                {
23395                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23396                                    std::string ex(str, iter.base());
23397                                    assert(ex == "******************-0x0p+0");
23398                                    assert(ios.width() == 0);
23399                                }
23400                                ios.width(25);
23401                                internal(ios);
23402                                {
23403                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23404                                    std::string ex(str, iter.base());
23405                                    assert(ex == "-******************0x0p+0");
23406                                    assert(ios.width() == 0);
23407                                }
23408                            }
23409                            ios.imbue(lg);
23410                            {
23411                                ios.width(0);
23412                                {
23413                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23414                                    std::string ex(str, iter.base());
23415                                    assert(ex == "-0x0p+0");
23416                                    assert(ios.width() == 0);
23417                                }
23418                                ios.width(25);
23419                                left(ios);
23420                                {
23421                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23422                                    std::string ex(str, iter.base());
23423                                    assert(ex == "-0x0p+0******************");
23424                                    assert(ios.width() == 0);
23425                                }
23426                                ios.width(25);
23427                                right(ios);
23428                                {
23429                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23430                                    std::string ex(str, iter.base());
23431                                    assert(ex == "******************-0x0p+0");
23432                                    assert(ios.width() == 0);
23433                                }
23434                                ios.width(25);
23435                                internal(ios);
23436                                {
23437                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23438                                    std::string ex(str, iter.base());
23439                                    assert(ex == "-******************0x0p+0");
23440                                    assert(ios.width() == 0);
23441                                }
23442                            }
23443                        }
23444                        showpoint(ios);
23445                        {
23446                            ios.imbue(lc);
23447                            {
23448                                ios.width(0);
23449                                {
23450                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23451                                    std::string ex(str, iter.base());
23452                                    assert(ex == "-0x0.p+0");
23453                                    assert(ios.width() == 0);
23454                                }
23455                                ios.width(25);
23456                                left(ios);
23457                                {
23458                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23459                                    std::string ex(str, iter.base());
23460                                    assert(ex == "-0x0.p+0*****************");
23461                                    assert(ios.width() == 0);
23462                                }
23463                                ios.width(25);
23464                                right(ios);
23465                                {
23466                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23467                                    std::string ex(str, iter.base());
23468                                    assert(ex == "*****************-0x0.p+0");
23469                                    assert(ios.width() == 0);
23470                                }
23471                                ios.width(25);
23472                                internal(ios);
23473                                {
23474                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23475                                    std::string ex(str, iter.base());
23476                                    assert(ex == "-*****************0x0.p+0");
23477                                    assert(ios.width() == 0);
23478                                }
23479                            }
23480                            ios.imbue(lg);
23481                            {
23482                                ios.width(0);
23483                                {
23484                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23485                                    std::string ex(str, iter.base());
23486                                    assert(ex == "-0x0;p+0");
23487                                    assert(ios.width() == 0);
23488                                }
23489                                ios.width(25);
23490                                left(ios);
23491                                {
23492                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23493                                    std::string ex(str, iter.base());
23494                                    assert(ex == "-0x0;p+0*****************");
23495                                    assert(ios.width() == 0);
23496                                }
23497                                ios.width(25);
23498                                right(ios);
23499                                {
23500                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23501                                    std::string ex(str, iter.base());
23502                                    assert(ex == "*****************-0x0;p+0");
23503                                    assert(ios.width() == 0);
23504                                }
23505                                ios.width(25);
23506                                internal(ios);
23507                                {
23508                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23509                                    std::string ex(str, iter.base());
23510                                    assert(ex == "-*****************0x0;p+0");
23511                                    assert(ios.width() == 0);
23512                                }
23513                            }
23514                        }
23515                    }
23516                }
23517                uppercase(ios);
23518                {
23519                    noshowpos(ios);
23520                    {
23521                        noshowpoint(ios);
23522                        {
23523                            ios.imbue(lc);
23524                            {
23525                                ios.width(0);
23526                                {
23527                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23528                                    std::string ex(str, iter.base());
23529                                    assert(ex == "-0X0P+0");
23530                                    assert(ios.width() == 0);
23531                                }
23532                                ios.width(25);
23533                                left(ios);
23534                                {
23535                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23536                                    std::string ex(str, iter.base());
23537                                    assert(ex == "-0X0P+0******************");
23538                                    assert(ios.width() == 0);
23539                                }
23540                                ios.width(25);
23541                                right(ios);
23542                                {
23543                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23544                                    std::string ex(str, iter.base());
23545                                    assert(ex == "******************-0X0P+0");
23546                                    assert(ios.width() == 0);
23547                                }
23548                                ios.width(25);
23549                                internal(ios);
23550                                {
23551                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23552                                    std::string ex(str, iter.base());
23553                                    assert(ex == "-******************0X0P+0");
23554                                    assert(ios.width() == 0);
23555                                }
23556                            }
23557                            ios.imbue(lg);
23558                            {
23559                                ios.width(0);
23560                                {
23561                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23562                                    std::string ex(str, iter.base());
23563                                    assert(ex == "-0X0P+0");
23564                                    assert(ios.width() == 0);
23565                                }
23566                                ios.width(25);
23567                                left(ios);
23568                                {
23569                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23570                                    std::string ex(str, iter.base());
23571                                    assert(ex == "-0X0P+0******************");
23572                                    assert(ios.width() == 0);
23573                                }
23574                                ios.width(25);
23575                                right(ios);
23576                                {
23577                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23578                                    std::string ex(str, iter.base());
23579                                    assert(ex == "******************-0X0P+0");
23580                                    assert(ios.width() == 0);
23581                                }
23582                                ios.width(25);
23583                                internal(ios);
23584                                {
23585                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23586                                    std::string ex(str, iter.base());
23587                                    assert(ex == "-******************0X0P+0");
23588                                    assert(ios.width() == 0);
23589                                }
23590                            }
23591                        }
23592                        showpoint(ios);
23593                        {
23594                            ios.imbue(lc);
23595                            {
23596                                ios.width(0);
23597                                {
23598                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23599                                    std::string ex(str, iter.base());
23600                                    assert(ex == "-0X0.P+0");
23601                                    assert(ios.width() == 0);
23602                                }
23603                                ios.width(25);
23604                                left(ios);
23605                                {
23606                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23607                                    std::string ex(str, iter.base());
23608                                    assert(ex == "-0X0.P+0*****************");
23609                                    assert(ios.width() == 0);
23610                                }
23611                                ios.width(25);
23612                                right(ios);
23613                                {
23614                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23615                                    std::string ex(str, iter.base());
23616                                    assert(ex == "*****************-0X0.P+0");
23617                                    assert(ios.width() == 0);
23618                                }
23619                                ios.width(25);
23620                                internal(ios);
23621                                {
23622                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23623                                    std::string ex(str, iter.base());
23624                                    assert(ex == "-*****************0X0.P+0");
23625                                    assert(ios.width() == 0);
23626                                }
23627                            }
23628                            ios.imbue(lg);
23629                            {
23630                                ios.width(0);
23631                                {
23632                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23633                                    std::string ex(str, iter.base());
23634                                    assert(ex == "-0X0;P+0");
23635                                    assert(ios.width() == 0);
23636                                }
23637                                ios.width(25);
23638                                left(ios);
23639                                {
23640                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23641                                    std::string ex(str, iter.base());
23642                                    assert(ex == "-0X0;P+0*****************");
23643                                    assert(ios.width() == 0);
23644                                }
23645                                ios.width(25);
23646                                right(ios);
23647                                {
23648                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23649                                    std::string ex(str, iter.base());
23650                                    assert(ex == "*****************-0X0;P+0");
23651                                    assert(ios.width() == 0);
23652                                }
23653                                ios.width(25);
23654                                internal(ios);
23655                                {
23656                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23657                                    std::string ex(str, iter.base());
23658                                    assert(ex == "-*****************0X0;P+0");
23659                                    assert(ios.width() == 0);
23660                                }
23661                            }
23662                        }
23663                    }
23664                    showpos(ios);
23665                    {
23666                        noshowpoint(ios);
23667                        {
23668                            ios.imbue(lc);
23669                            {
23670                                ios.width(0);
23671                                {
23672                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23673                                    std::string ex(str, iter.base());
23674                                    assert(ex == "-0X0P+0");
23675                                    assert(ios.width() == 0);
23676                                }
23677                                ios.width(25);
23678                                left(ios);
23679                                {
23680                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23681                                    std::string ex(str, iter.base());
23682                                    assert(ex == "-0X0P+0******************");
23683                                    assert(ios.width() == 0);
23684                                }
23685                                ios.width(25);
23686                                right(ios);
23687                                {
23688                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23689                                    std::string ex(str, iter.base());
23690                                    assert(ex == "******************-0X0P+0");
23691                                    assert(ios.width() == 0);
23692                                }
23693                                ios.width(25);
23694                                internal(ios);
23695                                {
23696                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23697                                    std::string ex(str, iter.base());
23698                                    assert(ex == "-******************0X0P+0");
23699                                    assert(ios.width() == 0);
23700                                }
23701                            }
23702                            ios.imbue(lg);
23703                            {
23704                                ios.width(0);
23705                                {
23706                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23707                                    std::string ex(str, iter.base());
23708                                    assert(ex == "-0X0P+0");
23709                                    assert(ios.width() == 0);
23710                                }
23711                                ios.width(25);
23712                                left(ios);
23713                                {
23714                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23715                                    std::string ex(str, iter.base());
23716                                    assert(ex == "-0X0P+0******************");
23717                                    assert(ios.width() == 0);
23718                                }
23719                                ios.width(25);
23720                                right(ios);
23721                                {
23722                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23723                                    std::string ex(str, iter.base());
23724                                    assert(ex == "******************-0X0P+0");
23725                                    assert(ios.width() == 0);
23726                                }
23727                                ios.width(25);
23728                                internal(ios);
23729                                {
23730                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23731                                    std::string ex(str, iter.base());
23732                                    assert(ex == "-******************0X0P+0");
23733                                    assert(ios.width() == 0);
23734                                }
23735                            }
23736                        }
23737                        showpoint(ios);
23738                        {
23739                            ios.imbue(lc);
23740                            {
23741                                ios.width(0);
23742                                {
23743                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23744                                    std::string ex(str, iter.base());
23745                                    assert(ex == "-0X0.P+0");
23746                                    assert(ios.width() == 0);
23747                                }
23748                                ios.width(25);
23749                                left(ios);
23750                                {
23751                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23752                                    std::string ex(str, iter.base());
23753                                    assert(ex == "-0X0.P+0*****************");
23754                                    assert(ios.width() == 0);
23755                                }
23756                                ios.width(25);
23757                                right(ios);
23758                                {
23759                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23760                                    std::string ex(str, iter.base());
23761                                    assert(ex == "*****************-0X0.P+0");
23762                                    assert(ios.width() == 0);
23763                                }
23764                                ios.width(25);
23765                                internal(ios);
23766                                {
23767                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23768                                    std::string ex(str, iter.base());
23769                                    assert(ex == "-*****************0X0.P+0");
23770                                    assert(ios.width() == 0);
23771                                }
23772                            }
23773                            ios.imbue(lg);
23774                            {
23775                                ios.width(0);
23776                                {
23777                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23778                                    std::string ex(str, iter.base());
23779                                    assert(ex == "-0X0;P+0");
23780                                    assert(ios.width() == 0);
23781                                }
23782                                ios.width(25);
23783                                left(ios);
23784                                {
23785                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23786                                    std::string ex(str, iter.base());
23787                                    assert(ex == "-0X0;P+0*****************");
23788                                    assert(ios.width() == 0);
23789                                }
23790                                ios.width(25);
23791                                right(ios);
23792                                {
23793                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23794                                    std::string ex(str, iter.base());
23795                                    assert(ex == "*****************-0X0;P+0");
23796                                    assert(ios.width() == 0);
23797                                }
23798                                ios.width(25);
23799                                internal(ios);
23800                                {
23801                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23802                                    std::string ex(str, iter.base());
23803                                    assert(ex == "-*****************0X0;P+0");
23804                                    assert(ios.width() == 0);
23805                                }
23806                            }
23807                        }
23808                    }
23809                }
23810            }
23811            ios.precision(6);
23812            {
23813                nouppercase(ios);
23814                {
23815                    noshowpos(ios);
23816                    {
23817                        noshowpoint(ios);
23818                        {
23819                            ios.imbue(lc);
23820                            {
23821                                ios.width(0);
23822                                {
23823                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23824                                    std::string ex(str, iter.base());
23825                                    assert(ex == "-0x0p+0");
23826                                    assert(ios.width() == 0);
23827                                }
23828                                ios.width(25);
23829                                left(ios);
23830                                {
23831                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23832                                    std::string ex(str, iter.base());
23833                                    assert(ex == "-0x0p+0******************");
23834                                    assert(ios.width() == 0);
23835                                }
23836                                ios.width(25);
23837                                right(ios);
23838                                {
23839                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23840                                    std::string ex(str, iter.base());
23841                                    assert(ex == "******************-0x0p+0");
23842                                    assert(ios.width() == 0);
23843                                }
23844                                ios.width(25);
23845                                internal(ios);
23846                                {
23847                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23848                                    std::string ex(str, iter.base());
23849                                    assert(ex == "-******************0x0p+0");
23850                                    assert(ios.width() == 0);
23851                                }
23852                            }
23853                            ios.imbue(lg);
23854                            {
23855                                ios.width(0);
23856                                {
23857                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23858                                    std::string ex(str, iter.base());
23859                                    assert(ex == "-0x0p+0");
23860                                    assert(ios.width() == 0);
23861                                }
23862                                ios.width(25);
23863                                left(ios);
23864                                {
23865                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23866                                    std::string ex(str, iter.base());
23867                                    assert(ex == "-0x0p+0******************");
23868                                    assert(ios.width() == 0);
23869                                }
23870                                ios.width(25);
23871                                right(ios);
23872                                {
23873                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23874                                    std::string ex(str, iter.base());
23875                                    assert(ex == "******************-0x0p+0");
23876                                    assert(ios.width() == 0);
23877                                }
23878                                ios.width(25);
23879                                internal(ios);
23880                                {
23881                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23882                                    std::string ex(str, iter.base());
23883                                    assert(ex == "-******************0x0p+0");
23884                                    assert(ios.width() == 0);
23885                                }
23886                            }
23887                        }
23888                        showpoint(ios);
23889                        {
23890                            ios.imbue(lc);
23891                            {
23892                                ios.width(0);
23893                                {
23894                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23895                                    std::string ex(str, iter.base());
23896                                    assert(ex == "-0x0.p+0");
23897                                    assert(ios.width() == 0);
23898                                }
23899                                ios.width(25);
23900                                left(ios);
23901                                {
23902                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23903                                    std::string ex(str, iter.base());
23904                                    assert(ex == "-0x0.p+0*****************");
23905                                    assert(ios.width() == 0);
23906                                }
23907                                ios.width(25);
23908                                right(ios);
23909                                {
23910                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23911                                    std::string ex(str, iter.base());
23912                                    assert(ex == "*****************-0x0.p+0");
23913                                    assert(ios.width() == 0);
23914                                }
23915                                ios.width(25);
23916                                internal(ios);
23917                                {
23918                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23919                                    std::string ex(str, iter.base());
23920                                    assert(ex == "-*****************0x0.p+0");
23921                                    assert(ios.width() == 0);
23922                                }
23923                            }
23924                            ios.imbue(lg);
23925                            {
23926                                ios.width(0);
23927                                {
23928                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23929                                    std::string ex(str, iter.base());
23930                                    assert(ex == "-0x0;p+0");
23931                                    assert(ios.width() == 0);
23932                                }
23933                                ios.width(25);
23934                                left(ios);
23935                                {
23936                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23937                                    std::string ex(str, iter.base());
23938                                    assert(ex == "-0x0;p+0*****************");
23939                                    assert(ios.width() == 0);
23940                                }
23941                                ios.width(25);
23942                                right(ios);
23943                                {
23944                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23945                                    std::string ex(str, iter.base());
23946                                    assert(ex == "*****************-0x0;p+0");
23947                                    assert(ios.width() == 0);
23948                                }
23949                                ios.width(25);
23950                                internal(ios);
23951                                {
23952                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23953                                    std::string ex(str, iter.base());
23954                                    assert(ex == "-*****************0x0;p+0");
23955                                    assert(ios.width() == 0);
23956                                }
23957                            }
23958                        }
23959                    }
23960                    showpos(ios);
23961                    {
23962                        noshowpoint(ios);
23963                        {
23964                            ios.imbue(lc);
23965                            {
23966                                ios.width(0);
23967                                {
23968                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23969                                    std::string ex(str, iter.base());
23970                                    assert(ex == "-0x0p+0");
23971                                    assert(ios.width() == 0);
23972                                }
23973                                ios.width(25);
23974                                left(ios);
23975                                {
23976                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23977                                    std::string ex(str, iter.base());
23978                                    assert(ex == "-0x0p+0******************");
23979                                    assert(ios.width() == 0);
23980                                }
23981                                ios.width(25);
23982                                right(ios);
23983                                {
23984                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23985                                    std::string ex(str, iter.base());
23986                                    assert(ex == "******************-0x0p+0");
23987                                    assert(ios.width() == 0);
23988                                }
23989                                ios.width(25);
23990                                internal(ios);
23991                                {
23992                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
23993                                    std::string ex(str, iter.base());
23994                                    assert(ex == "-******************0x0p+0");
23995                                    assert(ios.width() == 0);
23996                                }
23997                            }
23998                            ios.imbue(lg);
23999                            {
24000                                ios.width(0);
24001                                {
24002                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24003                                    std::string ex(str, iter.base());
24004                                    assert(ex == "-0x0p+0");
24005                                    assert(ios.width() == 0);
24006                                }
24007                                ios.width(25);
24008                                left(ios);
24009                                {
24010                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24011                                    std::string ex(str, iter.base());
24012                                    assert(ex == "-0x0p+0******************");
24013                                    assert(ios.width() == 0);
24014                                }
24015                                ios.width(25);
24016                                right(ios);
24017                                {
24018                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24019                                    std::string ex(str, iter.base());
24020                                    assert(ex == "******************-0x0p+0");
24021                                    assert(ios.width() == 0);
24022                                }
24023                                ios.width(25);
24024                                internal(ios);
24025                                {
24026                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24027                                    std::string ex(str, iter.base());
24028                                    assert(ex == "-******************0x0p+0");
24029                                    assert(ios.width() == 0);
24030                                }
24031                            }
24032                        }
24033                        showpoint(ios);
24034                        {
24035                            ios.imbue(lc);
24036                            {
24037                                ios.width(0);
24038                                {
24039                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24040                                    std::string ex(str, iter.base());
24041                                    assert(ex == "-0x0.p+0");
24042                                    assert(ios.width() == 0);
24043                                }
24044                                ios.width(25);
24045                                left(ios);
24046                                {
24047                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24048                                    std::string ex(str, iter.base());
24049                                    assert(ex == "-0x0.p+0*****************");
24050                                    assert(ios.width() == 0);
24051                                }
24052                                ios.width(25);
24053                                right(ios);
24054                                {
24055                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24056                                    std::string ex(str, iter.base());
24057                                    assert(ex == "*****************-0x0.p+0");
24058                                    assert(ios.width() == 0);
24059                                }
24060                                ios.width(25);
24061                                internal(ios);
24062                                {
24063                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24064                                    std::string ex(str, iter.base());
24065                                    assert(ex == "-*****************0x0.p+0");
24066                                    assert(ios.width() == 0);
24067                                }
24068                            }
24069                            ios.imbue(lg);
24070                            {
24071                                ios.width(0);
24072                                {
24073                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24074                                    std::string ex(str, iter.base());
24075                                    assert(ex == "-0x0;p+0");
24076                                    assert(ios.width() == 0);
24077                                }
24078                                ios.width(25);
24079                                left(ios);
24080                                {
24081                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24082                                    std::string ex(str, iter.base());
24083                                    assert(ex == "-0x0;p+0*****************");
24084                                    assert(ios.width() == 0);
24085                                }
24086                                ios.width(25);
24087                                right(ios);
24088                                {
24089                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24090                                    std::string ex(str, iter.base());
24091                                    assert(ex == "*****************-0x0;p+0");
24092                                    assert(ios.width() == 0);
24093                                }
24094                                ios.width(25);
24095                                internal(ios);
24096                                {
24097                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24098                                    std::string ex(str, iter.base());
24099                                    assert(ex == "-*****************0x0;p+0");
24100                                    assert(ios.width() == 0);
24101                                }
24102                            }
24103                        }
24104                    }
24105                }
24106                uppercase(ios);
24107                {
24108                    noshowpos(ios);
24109                    {
24110                        noshowpoint(ios);
24111                        {
24112                            ios.imbue(lc);
24113                            {
24114                                ios.width(0);
24115                                {
24116                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24117                                    std::string ex(str, iter.base());
24118                                    assert(ex == "-0X0P+0");
24119                                    assert(ios.width() == 0);
24120                                }
24121                                ios.width(25);
24122                                left(ios);
24123                                {
24124                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24125                                    std::string ex(str, iter.base());
24126                                    assert(ex == "-0X0P+0******************");
24127                                    assert(ios.width() == 0);
24128                                }
24129                                ios.width(25);
24130                                right(ios);
24131                                {
24132                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24133                                    std::string ex(str, iter.base());
24134                                    assert(ex == "******************-0X0P+0");
24135                                    assert(ios.width() == 0);
24136                                }
24137                                ios.width(25);
24138                                internal(ios);
24139                                {
24140                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24141                                    std::string ex(str, iter.base());
24142                                    assert(ex == "-******************0X0P+0");
24143                                    assert(ios.width() == 0);
24144                                }
24145                            }
24146                            ios.imbue(lg);
24147                            {
24148                                ios.width(0);
24149                                {
24150                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24151                                    std::string ex(str, iter.base());
24152                                    assert(ex == "-0X0P+0");
24153                                    assert(ios.width() == 0);
24154                                }
24155                                ios.width(25);
24156                                left(ios);
24157                                {
24158                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24159                                    std::string ex(str, iter.base());
24160                                    assert(ex == "-0X0P+0******************");
24161                                    assert(ios.width() == 0);
24162                                }
24163                                ios.width(25);
24164                                right(ios);
24165                                {
24166                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24167                                    std::string ex(str, iter.base());
24168                                    assert(ex == "******************-0X0P+0");
24169                                    assert(ios.width() == 0);
24170                                }
24171                                ios.width(25);
24172                                internal(ios);
24173                                {
24174                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24175                                    std::string ex(str, iter.base());
24176                                    assert(ex == "-******************0X0P+0");
24177                                    assert(ios.width() == 0);
24178                                }
24179                            }
24180                        }
24181                        showpoint(ios);
24182                        {
24183                            ios.imbue(lc);
24184                            {
24185                                ios.width(0);
24186                                {
24187                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24188                                    std::string ex(str, iter.base());
24189                                    assert(ex == "-0X0.P+0");
24190                                    assert(ios.width() == 0);
24191                                }
24192                                ios.width(25);
24193                                left(ios);
24194                                {
24195                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24196                                    std::string ex(str, iter.base());
24197                                    assert(ex == "-0X0.P+0*****************");
24198                                    assert(ios.width() == 0);
24199                                }
24200                                ios.width(25);
24201                                right(ios);
24202                                {
24203                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24204                                    std::string ex(str, iter.base());
24205                                    assert(ex == "*****************-0X0.P+0");
24206                                    assert(ios.width() == 0);
24207                                }
24208                                ios.width(25);
24209                                internal(ios);
24210                                {
24211                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24212                                    std::string ex(str, iter.base());
24213                                    assert(ex == "-*****************0X0.P+0");
24214                                    assert(ios.width() == 0);
24215                                }
24216                            }
24217                            ios.imbue(lg);
24218                            {
24219                                ios.width(0);
24220                                {
24221                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24222                                    std::string ex(str, iter.base());
24223                                    assert(ex == "-0X0;P+0");
24224                                    assert(ios.width() == 0);
24225                                }
24226                                ios.width(25);
24227                                left(ios);
24228                                {
24229                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24230                                    std::string ex(str, iter.base());
24231                                    assert(ex == "-0X0;P+0*****************");
24232                                    assert(ios.width() == 0);
24233                                }
24234                                ios.width(25);
24235                                right(ios);
24236                                {
24237                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24238                                    std::string ex(str, iter.base());
24239                                    assert(ex == "*****************-0X0;P+0");
24240                                    assert(ios.width() == 0);
24241                                }
24242                                ios.width(25);
24243                                internal(ios);
24244                                {
24245                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24246                                    std::string ex(str, iter.base());
24247                                    assert(ex == "-*****************0X0;P+0");
24248                                    assert(ios.width() == 0);
24249                                }
24250                            }
24251                        }
24252                    }
24253                    showpos(ios);
24254                    {
24255                        noshowpoint(ios);
24256                        {
24257                            ios.imbue(lc);
24258                            {
24259                                ios.width(0);
24260                                {
24261                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24262                                    std::string ex(str, iter.base());
24263                                    assert(ex == "-0X0P+0");
24264                                    assert(ios.width() == 0);
24265                                }
24266                                ios.width(25);
24267                                left(ios);
24268                                {
24269                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24270                                    std::string ex(str, iter.base());
24271                                    assert(ex == "-0X0P+0******************");
24272                                    assert(ios.width() == 0);
24273                                }
24274                                ios.width(25);
24275                                right(ios);
24276                                {
24277                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24278                                    std::string ex(str, iter.base());
24279                                    assert(ex == "******************-0X0P+0");
24280                                    assert(ios.width() == 0);
24281                                }
24282                                ios.width(25);
24283                                internal(ios);
24284                                {
24285                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24286                                    std::string ex(str, iter.base());
24287                                    assert(ex == "-******************0X0P+0");
24288                                    assert(ios.width() == 0);
24289                                }
24290                            }
24291                            ios.imbue(lg);
24292                            {
24293                                ios.width(0);
24294                                {
24295                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24296                                    std::string ex(str, iter.base());
24297                                    assert(ex == "-0X0P+0");
24298                                    assert(ios.width() == 0);
24299                                }
24300                                ios.width(25);
24301                                left(ios);
24302                                {
24303                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24304                                    std::string ex(str, iter.base());
24305                                    assert(ex == "-0X0P+0******************");
24306                                    assert(ios.width() == 0);
24307                                }
24308                                ios.width(25);
24309                                right(ios);
24310                                {
24311                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24312                                    std::string ex(str, iter.base());
24313                                    assert(ex == "******************-0X0P+0");
24314                                    assert(ios.width() == 0);
24315                                }
24316                                ios.width(25);
24317                                internal(ios);
24318                                {
24319                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24320                                    std::string ex(str, iter.base());
24321                                    assert(ex == "-******************0X0P+0");
24322                                    assert(ios.width() == 0);
24323                                }
24324                            }
24325                        }
24326                        showpoint(ios);
24327                        {
24328                            ios.imbue(lc);
24329                            {
24330                                ios.width(0);
24331                                {
24332                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24333                                    std::string ex(str, iter.base());
24334                                    assert(ex == "-0X0.P+0");
24335                                    assert(ios.width() == 0);
24336                                }
24337                                ios.width(25);
24338                                left(ios);
24339                                {
24340                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24341                                    std::string ex(str, iter.base());
24342                                    assert(ex == "-0X0.P+0*****************");
24343                                    assert(ios.width() == 0);
24344                                }
24345                                ios.width(25);
24346                                right(ios);
24347                                {
24348                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24349                                    std::string ex(str, iter.base());
24350                                    assert(ex == "*****************-0X0.P+0");
24351                                    assert(ios.width() == 0);
24352                                }
24353                                ios.width(25);
24354                                internal(ios);
24355                                {
24356                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24357                                    std::string ex(str, iter.base());
24358                                    assert(ex == "-*****************0X0.P+0");
24359                                    assert(ios.width() == 0);
24360                                }
24361                            }
24362                            ios.imbue(lg);
24363                            {
24364                                ios.width(0);
24365                                {
24366                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24367                                    std::string ex(str, iter.base());
24368                                    assert(ex == "-0X0;P+0");
24369                                    assert(ios.width() == 0);
24370                                }
24371                                ios.width(25);
24372                                left(ios);
24373                                {
24374                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24375                                    std::string ex(str, iter.base());
24376                                    assert(ex == "-0X0;P+0*****************");
24377                                    assert(ios.width() == 0);
24378                                }
24379                                ios.width(25);
24380                                right(ios);
24381                                {
24382                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24383                                    std::string ex(str, iter.base());
24384                                    assert(ex == "*****************-0X0;P+0");
24385                                    assert(ios.width() == 0);
24386                                }
24387                                ios.width(25);
24388                                internal(ios);
24389                                {
24390                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24391                                    std::string ex(str, iter.base());
24392                                    assert(ex == "-*****************0X0;P+0");
24393                                    assert(ios.width() == 0);
24394                                }
24395                            }
24396                        }
24397                    }
24398                }
24399            }
24400            ios.precision(16);
24401            {
24402            }
24403            ios.precision(60);
24404            {
24405            }
24406        }
24407    }
24408}
24409
24410void test12()
24411{
24412    char str[200];
24413    output_iterator<char*> iter;
24414    std::locale lc = std::locale::classic();
24415    std::locale lg(lc, new my_numpunct);
24416    const my_facet f(1);
24417    {
24418        long double v = 1234567890.125;
24419        std::ios ios(0);
24420        hexfloat(ios);
24421        // %a
24422        {
24423            ios.precision(0);
24424            {
24425                nouppercase(ios);
24426                {
24427                    noshowpos(ios);
24428                    {
24429                        noshowpoint(ios);
24430                        {
24431                            ios.imbue(lc);
24432                            {
24433                                ios.width(0);
24434                                {
24435                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24436                                    std::string ex(str, iter.base());
24437                                    assert(ex == "0x9.32c05a44p+27");
24438                                    assert(ios.width() == 0);
24439                                }
24440                                ios.width(25);
24441                                left(ios);
24442                                {
24443                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24444                                    std::string ex(str, iter.base());
24445                                    assert(ex == "0x9.32c05a44p+27*********");
24446                                    assert(ios.width() == 0);
24447                                }
24448                                ios.width(25);
24449                                right(ios);
24450                                {
24451                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24452                                    std::string ex(str, iter.base());
24453                                    assert(ex == "*********0x9.32c05a44p+27");
24454                                    assert(ios.width() == 0);
24455                                }
24456                                ios.width(25);
24457                                internal(ios);
24458                                {
24459                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24460                                    std::string ex(str, iter.base());
24461                                    assert(ex == "0x*********9.32c05a44p+27");
24462                                    assert(ios.width() == 0);
24463                                }
24464                            }
24465                            ios.imbue(lg);
24466                            {
24467                                ios.width(0);
24468                                {
24469                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24470                                    std::string ex(str, iter.base());
24471                                    assert(ex == "0x9;32c05a44p+27");
24472                                    assert(ios.width() == 0);
24473                                }
24474                                ios.width(25);
24475                                left(ios);
24476                                {
24477                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24478                                    std::string ex(str, iter.base());
24479                                    assert(ex == "0x9;32c05a44p+27*********");
24480                                    assert(ios.width() == 0);
24481                                }
24482                                ios.width(25);
24483                                right(ios);
24484                                {
24485                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24486                                    std::string ex(str, iter.base());
24487                                    assert(ex == "*********0x9;32c05a44p+27");
24488                                    assert(ios.width() == 0);
24489                                }
24490                                ios.width(25);
24491                                internal(ios);
24492                                {
24493                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24494                                    std::string ex(str, iter.base());
24495                                    assert(ex == "0x*********9;32c05a44p+27");
24496                                    assert(ios.width() == 0);
24497                                }
24498                            }
24499                        }
24500                        showpoint(ios);
24501                        {
24502                            ios.imbue(lc);
24503                            {
24504                                ios.width(0);
24505                                {
24506                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24507                                    std::string ex(str, iter.base());
24508                                    assert(ex == "0x9.32c05a44p+27");
24509                                    assert(ios.width() == 0);
24510                                }
24511                                ios.width(25);
24512                                left(ios);
24513                                {
24514                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24515                                    std::string ex(str, iter.base());
24516                                    assert(ex == "0x9.32c05a44p+27*********");
24517                                    assert(ios.width() == 0);
24518                                }
24519                                ios.width(25);
24520                                right(ios);
24521                                {
24522                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24523                                    std::string ex(str, iter.base());
24524                                    assert(ex == "*********0x9.32c05a44p+27");
24525                                    assert(ios.width() == 0);
24526                                }
24527                                ios.width(25);
24528                                internal(ios);
24529                                {
24530                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24531                                    std::string ex(str, iter.base());
24532                                    assert(ex == "0x*********9.32c05a44p+27");
24533                                    assert(ios.width() == 0);
24534                                }
24535                            }
24536                            ios.imbue(lg);
24537                            {
24538                                ios.width(0);
24539                                {
24540                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24541                                    std::string ex(str, iter.base());
24542                                    assert(ex == "0x9;32c05a44p+27");
24543                                    assert(ios.width() == 0);
24544                                }
24545                                ios.width(25);
24546                                left(ios);
24547                                {
24548                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24549                                    std::string ex(str, iter.base());
24550                                    assert(ex == "0x9;32c05a44p+27*********");
24551                                    assert(ios.width() == 0);
24552                                }
24553                                ios.width(25);
24554                                right(ios);
24555                                {
24556                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24557                                    std::string ex(str, iter.base());
24558                                    assert(ex == "*********0x9;32c05a44p+27");
24559                                    assert(ios.width() == 0);
24560                                }
24561                                ios.width(25);
24562                                internal(ios);
24563                                {
24564                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24565                                    std::string ex(str, iter.base());
24566                                    assert(ex == "0x*********9;32c05a44p+27");
24567                                    assert(ios.width() == 0);
24568                                }
24569                            }
24570                        }
24571                    }
24572                    showpos(ios);
24573                    {
24574                        noshowpoint(ios);
24575                        {
24576                            ios.imbue(lc);
24577                            {
24578                                ios.width(0);
24579                                {
24580                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24581                                    std::string ex(str, iter.base());
24582                                    assert(ex == "+0x9.32c05a44p+27");
24583                                    assert(ios.width() == 0);
24584                                }
24585                                ios.width(25);
24586                                left(ios);
24587                                {
24588                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24589                                    std::string ex(str, iter.base());
24590                                    assert(ex == "+0x9.32c05a44p+27********");
24591                                    assert(ios.width() == 0);
24592                                }
24593                                ios.width(25);
24594                                right(ios);
24595                                {
24596                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24597                                    std::string ex(str, iter.base());
24598                                    assert(ex == "********+0x9.32c05a44p+27");
24599                                    assert(ios.width() == 0);
24600                                }
24601                                ios.width(25);
24602                                internal(ios);
24603                                {
24604                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24605                                    std::string ex(str, iter.base());
24606                                    assert(ex == "+********0x9.32c05a44p+27");
24607                                    assert(ios.width() == 0);
24608                                }
24609                            }
24610                            ios.imbue(lg);
24611                            {
24612                                ios.width(0);
24613                                {
24614                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24615                                    std::string ex(str, iter.base());
24616                                    assert(ex == "+0x9;32c05a44p+27");
24617                                    assert(ios.width() == 0);
24618                                }
24619                                ios.width(25);
24620                                left(ios);
24621                                {
24622                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24623                                    std::string ex(str, iter.base());
24624                                    assert(ex == "+0x9;32c05a44p+27********");
24625                                    assert(ios.width() == 0);
24626                                }
24627                                ios.width(25);
24628                                right(ios);
24629                                {
24630                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24631                                    std::string ex(str, iter.base());
24632                                    assert(ex == "********+0x9;32c05a44p+27");
24633                                    assert(ios.width() == 0);
24634                                }
24635                                ios.width(25);
24636                                internal(ios);
24637                                {
24638                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24639                                    std::string ex(str, iter.base());
24640                                    assert(ex == "+********0x9;32c05a44p+27");
24641                                    assert(ios.width() == 0);
24642                                }
24643                            }
24644                        }
24645                        showpoint(ios);
24646                        {
24647                            ios.imbue(lc);
24648                            {
24649                                ios.width(0);
24650                                {
24651                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24652                                    std::string ex(str, iter.base());
24653                                    assert(ex == "+0x9.32c05a44p+27");
24654                                    assert(ios.width() == 0);
24655                                }
24656                                ios.width(25);
24657                                left(ios);
24658                                {
24659                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24660                                    std::string ex(str, iter.base());
24661                                    assert(ex == "+0x9.32c05a44p+27********");
24662                                    assert(ios.width() == 0);
24663                                }
24664                                ios.width(25);
24665                                right(ios);
24666                                {
24667                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24668                                    std::string ex(str, iter.base());
24669                                    assert(ex == "********+0x9.32c05a44p+27");
24670                                    assert(ios.width() == 0);
24671                                }
24672                                ios.width(25);
24673                                internal(ios);
24674                                {
24675                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24676                                    std::string ex(str, iter.base());
24677                                    assert(ex == "+********0x9.32c05a44p+27");
24678                                    assert(ios.width() == 0);
24679                                }
24680                            }
24681                            ios.imbue(lg);
24682                            {
24683                                ios.width(0);
24684                                {
24685                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24686                                    std::string ex(str, iter.base());
24687                                    assert(ex == "+0x9;32c05a44p+27");
24688                                    assert(ios.width() == 0);
24689                                }
24690                                ios.width(25);
24691                                left(ios);
24692                                {
24693                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24694                                    std::string ex(str, iter.base());
24695                                    assert(ex == "+0x9;32c05a44p+27********");
24696                                    assert(ios.width() == 0);
24697                                }
24698                                ios.width(25);
24699                                right(ios);
24700                                {
24701                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24702                                    std::string ex(str, iter.base());
24703                                    assert(ex == "********+0x9;32c05a44p+27");
24704                                    assert(ios.width() == 0);
24705                                }
24706                                ios.width(25);
24707                                internal(ios);
24708                                {
24709                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24710                                    std::string ex(str, iter.base());
24711                                    assert(ex == "+********0x9;32c05a44p+27");
24712                                    assert(ios.width() == 0);
24713                                }
24714                            }
24715                        }
24716                    }
24717                }
24718                uppercase(ios);
24719                {
24720                    noshowpos(ios);
24721                    {
24722                        noshowpoint(ios);
24723                        {
24724                            ios.imbue(lc);
24725                            {
24726                                ios.width(0);
24727                                {
24728                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24729                                    std::string ex(str, iter.base());
24730                                    assert(ex == "0X9.32C05A44P+27");
24731                                    assert(ios.width() == 0);
24732                                }
24733                                ios.width(25);
24734                                left(ios);
24735                                {
24736                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24737                                    std::string ex(str, iter.base());
24738                                    assert(ex == "0X9.32C05A44P+27*********");
24739                                    assert(ios.width() == 0);
24740                                }
24741                                ios.width(25);
24742                                right(ios);
24743                                {
24744                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24745                                    std::string ex(str, iter.base());
24746                                    assert(ex == "*********0X9.32C05A44P+27");
24747                                    assert(ios.width() == 0);
24748                                }
24749                                ios.width(25);
24750                                internal(ios);
24751                                {
24752                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24753                                    std::string ex(str, iter.base());
24754                                    assert(ex == "0X*********9.32C05A44P+27");
24755                                    assert(ios.width() == 0);
24756                                }
24757                            }
24758                            ios.imbue(lg);
24759                            {
24760                                ios.width(0);
24761                                {
24762                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24763                                    std::string ex(str, iter.base());
24764                                    assert(ex == "0X9;32C05A44P+27");
24765                                    assert(ios.width() == 0);
24766                                }
24767                                ios.width(25);
24768                                left(ios);
24769                                {
24770                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24771                                    std::string ex(str, iter.base());
24772                                    assert(ex == "0X9;32C05A44P+27*********");
24773                                    assert(ios.width() == 0);
24774                                }
24775                                ios.width(25);
24776                                right(ios);
24777                                {
24778                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24779                                    std::string ex(str, iter.base());
24780                                    assert(ex == "*********0X9;32C05A44P+27");
24781                                    assert(ios.width() == 0);
24782                                }
24783                                ios.width(25);
24784                                internal(ios);
24785                                {
24786                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24787                                    std::string ex(str, iter.base());
24788                                    assert(ex == "0X*********9;32C05A44P+27");
24789                                    assert(ios.width() == 0);
24790                                }
24791                            }
24792                        }
24793                        showpoint(ios);
24794                        {
24795                            ios.imbue(lc);
24796                            {
24797                                ios.width(0);
24798                                {
24799                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24800                                    std::string ex(str, iter.base());
24801                                    assert(ex == "0X9.32C05A44P+27");
24802                                    assert(ios.width() == 0);
24803                                }
24804                                ios.width(25);
24805                                left(ios);
24806                                {
24807                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24808                                    std::string ex(str, iter.base());
24809                                    assert(ex == "0X9.32C05A44P+27*********");
24810                                    assert(ios.width() == 0);
24811                                }
24812                                ios.width(25);
24813                                right(ios);
24814                                {
24815                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24816                                    std::string ex(str, iter.base());
24817                                    assert(ex == "*********0X9.32C05A44P+27");
24818                                    assert(ios.width() == 0);
24819                                }
24820                                ios.width(25);
24821                                internal(ios);
24822                                {
24823                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24824                                    std::string ex(str, iter.base());
24825                                    assert(ex == "0X*********9.32C05A44P+27");
24826                                    assert(ios.width() == 0);
24827                                }
24828                            }
24829                            ios.imbue(lg);
24830                            {
24831                                ios.width(0);
24832                                {
24833                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24834                                    std::string ex(str, iter.base());
24835                                    assert(ex == "0X9;32C05A44P+27");
24836                                    assert(ios.width() == 0);
24837                                }
24838                                ios.width(25);
24839                                left(ios);
24840                                {
24841                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24842                                    std::string ex(str, iter.base());
24843                                    assert(ex == "0X9;32C05A44P+27*********");
24844                                    assert(ios.width() == 0);
24845                                }
24846                                ios.width(25);
24847                                right(ios);
24848                                {
24849                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24850                                    std::string ex(str, iter.base());
24851                                    assert(ex == "*********0X9;32C05A44P+27");
24852                                    assert(ios.width() == 0);
24853                                }
24854                                ios.width(25);
24855                                internal(ios);
24856                                {
24857                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24858                                    std::string ex(str, iter.base());
24859                                    assert(ex == "0X*********9;32C05A44P+27");
24860                                    assert(ios.width() == 0);
24861                                }
24862                            }
24863                        }
24864                    }
24865                    showpos(ios);
24866                    {
24867                        noshowpoint(ios);
24868                        {
24869                            ios.imbue(lc);
24870                            {
24871                                ios.width(0);
24872                                {
24873                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24874                                    std::string ex(str, iter.base());
24875                                    assert(ex == "+0X9.32C05A44P+27");
24876                                    assert(ios.width() == 0);
24877                                }
24878                                ios.width(25);
24879                                left(ios);
24880                                {
24881                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24882                                    std::string ex(str, iter.base());
24883                                    assert(ex == "+0X9.32C05A44P+27********");
24884                                    assert(ios.width() == 0);
24885                                }
24886                                ios.width(25);
24887                                right(ios);
24888                                {
24889                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24890                                    std::string ex(str, iter.base());
24891                                    assert(ex == "********+0X9.32C05A44P+27");
24892                                    assert(ios.width() == 0);
24893                                }
24894                                ios.width(25);
24895                                internal(ios);
24896                                {
24897                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24898                                    std::string ex(str, iter.base());
24899                                    assert(ex == "+********0X9.32C05A44P+27");
24900                                    assert(ios.width() == 0);
24901                                }
24902                            }
24903                            ios.imbue(lg);
24904                            {
24905                                ios.width(0);
24906                                {
24907                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24908                                    std::string ex(str, iter.base());
24909                                    assert(ex == "+0X9;32C05A44P+27");
24910                                    assert(ios.width() == 0);
24911                                }
24912                                ios.width(25);
24913                                left(ios);
24914                                {
24915                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24916                                    std::string ex(str, iter.base());
24917                                    assert(ex == "+0X9;32C05A44P+27********");
24918                                    assert(ios.width() == 0);
24919                                }
24920                                ios.width(25);
24921                                right(ios);
24922                                {
24923                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24924                                    std::string ex(str, iter.base());
24925                                    assert(ex == "********+0X9;32C05A44P+27");
24926                                    assert(ios.width() == 0);
24927                                }
24928                                ios.width(25);
24929                                internal(ios);
24930                                {
24931                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24932                                    std::string ex(str, iter.base());
24933                                    assert(ex == "+********0X9;32C05A44P+27");
24934                                    assert(ios.width() == 0);
24935                                }
24936                            }
24937                        }
24938                        showpoint(ios);
24939                        {
24940                            ios.imbue(lc);
24941                            {
24942                                ios.width(0);
24943                                {
24944                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24945                                    std::string ex(str, iter.base());
24946                                    assert(ex == "+0X9.32C05A44P+27");
24947                                    assert(ios.width() == 0);
24948                                }
24949                                ios.width(25);
24950                                left(ios);
24951                                {
24952                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24953                                    std::string ex(str, iter.base());
24954                                    assert(ex == "+0X9.32C05A44P+27********");
24955                                    assert(ios.width() == 0);
24956                                }
24957                                ios.width(25);
24958                                right(ios);
24959                                {
24960                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24961                                    std::string ex(str, iter.base());
24962                                    assert(ex == "********+0X9.32C05A44P+27");
24963                                    assert(ios.width() == 0);
24964                                }
24965                                ios.width(25);
24966                                internal(ios);
24967                                {
24968                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24969                                    std::string ex(str, iter.base());
24970                                    assert(ex == "+********0X9.32C05A44P+27");
24971                                    assert(ios.width() == 0);
24972                                }
24973                            }
24974                            ios.imbue(lg);
24975                            {
24976                                ios.width(0);
24977                                {
24978                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24979                                    std::string ex(str, iter.base());
24980                                    assert(ex == "+0X9;32C05A44P+27");
24981                                    assert(ios.width() == 0);
24982                                }
24983                                ios.width(25);
24984                                left(ios);
24985                                {
24986                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24987                                    std::string ex(str, iter.base());
24988                                    assert(ex == "+0X9;32C05A44P+27********");
24989                                    assert(ios.width() == 0);
24990                                }
24991                                ios.width(25);
24992                                right(ios);
24993                                {
24994                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
24995                                    std::string ex(str, iter.base());
24996                                    assert(ex == "********+0X9;32C05A44P+27");
24997                                    assert(ios.width() == 0);
24998                                }
24999                                ios.width(25);
25000                                internal(ios);
25001                                {
25002                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25003                                    std::string ex(str, iter.base());
25004                                    assert(ex == "+********0X9;32C05A44P+27");
25005                                    assert(ios.width() == 0);
25006                                }
25007                            }
25008                        }
25009                    }
25010                }
25011            }
25012            ios.precision(1);
25013            {
25014                nouppercase(ios);
25015                {
25016                    noshowpos(ios);
25017                    {
25018                        noshowpoint(ios);
25019                        {
25020                            ios.imbue(lc);
25021                            {
25022                                ios.width(0);
25023                                {
25024                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25025                                    std::string ex(str, iter.base());
25026                                    assert(ex == "0x9.32c05a44p+27");
25027                                    assert(ios.width() == 0);
25028                                }
25029                                ios.width(25);
25030                                left(ios);
25031                                {
25032                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25033                                    std::string ex(str, iter.base());
25034                                    assert(ex == "0x9.32c05a44p+27*********");
25035                                    assert(ios.width() == 0);
25036                                }
25037                                ios.width(25);
25038                                right(ios);
25039                                {
25040                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25041                                    std::string ex(str, iter.base());
25042                                    assert(ex == "*********0x9.32c05a44p+27");
25043                                    assert(ios.width() == 0);
25044                                }
25045                                ios.width(25);
25046                                internal(ios);
25047                                {
25048                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25049                                    std::string ex(str, iter.base());
25050                                    assert(ex == "0x*********9.32c05a44p+27");
25051                                    assert(ios.width() == 0);
25052                                }
25053                            }
25054                            ios.imbue(lg);
25055                            {
25056                                ios.width(0);
25057                                {
25058                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25059                                    std::string ex(str, iter.base());
25060                                    assert(ex == "0x9;32c05a44p+27");
25061                                    assert(ios.width() == 0);
25062                                }
25063                                ios.width(25);
25064                                left(ios);
25065                                {
25066                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25067                                    std::string ex(str, iter.base());
25068                                    assert(ex == "0x9;32c05a44p+27*********");
25069                                    assert(ios.width() == 0);
25070                                }
25071                                ios.width(25);
25072                                right(ios);
25073                                {
25074                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25075                                    std::string ex(str, iter.base());
25076                                    assert(ex == "*********0x9;32c05a44p+27");
25077                                    assert(ios.width() == 0);
25078                                }
25079                                ios.width(25);
25080                                internal(ios);
25081                                {
25082                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25083                                    std::string ex(str, iter.base());
25084                                    assert(ex == "0x*********9;32c05a44p+27");
25085                                    assert(ios.width() == 0);
25086                                }
25087                            }
25088                        }
25089                        showpoint(ios);
25090                        {
25091                            ios.imbue(lc);
25092                            {
25093                                ios.width(0);
25094                                {
25095                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25096                                    std::string ex(str, iter.base());
25097                                    assert(ex == "0x9.32c05a44p+27");
25098                                    assert(ios.width() == 0);
25099                                }
25100                                ios.width(25);
25101                                left(ios);
25102                                {
25103                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25104                                    std::string ex(str, iter.base());
25105                                    assert(ex == "0x9.32c05a44p+27*********");
25106                                    assert(ios.width() == 0);
25107                                }
25108                                ios.width(25);
25109                                right(ios);
25110                                {
25111                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25112                                    std::string ex(str, iter.base());
25113                                    assert(ex == "*********0x9.32c05a44p+27");
25114                                    assert(ios.width() == 0);
25115                                }
25116                                ios.width(25);
25117                                internal(ios);
25118                                {
25119                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25120                                    std::string ex(str, iter.base());
25121                                    assert(ex == "0x*********9.32c05a44p+27");
25122                                    assert(ios.width() == 0);
25123                                }
25124                            }
25125                            ios.imbue(lg);
25126                            {
25127                                ios.width(0);
25128                                {
25129                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25130                                    std::string ex(str, iter.base());
25131                                    assert(ex == "0x9;32c05a44p+27");
25132                                    assert(ios.width() == 0);
25133                                }
25134                                ios.width(25);
25135                                left(ios);
25136                                {
25137                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25138                                    std::string ex(str, iter.base());
25139                                    assert(ex == "0x9;32c05a44p+27*********");
25140                                    assert(ios.width() == 0);
25141                                }
25142                                ios.width(25);
25143                                right(ios);
25144                                {
25145                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25146                                    std::string ex(str, iter.base());
25147                                    assert(ex == "*********0x9;32c05a44p+27");
25148                                    assert(ios.width() == 0);
25149                                }
25150                                ios.width(25);
25151                                internal(ios);
25152                                {
25153                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25154                                    std::string ex(str, iter.base());
25155                                    assert(ex == "0x*********9;32c05a44p+27");
25156                                    assert(ios.width() == 0);
25157                                }
25158                            }
25159                        }
25160                    }
25161                    showpos(ios);
25162                    {
25163                        noshowpoint(ios);
25164                        {
25165                            ios.imbue(lc);
25166                            {
25167                                ios.width(0);
25168                                {
25169                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25170                                    std::string ex(str, iter.base());
25171                                    assert(ex == "+0x9.32c05a44p+27");
25172                                    assert(ios.width() == 0);
25173                                }
25174                                ios.width(25);
25175                                left(ios);
25176                                {
25177                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25178                                    std::string ex(str, iter.base());
25179                                    assert(ex == "+0x9.32c05a44p+27********");
25180                                    assert(ios.width() == 0);
25181                                }
25182                                ios.width(25);
25183                                right(ios);
25184                                {
25185                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25186                                    std::string ex(str, iter.base());
25187                                    assert(ex == "********+0x9.32c05a44p+27");
25188                                    assert(ios.width() == 0);
25189                                }
25190                                ios.width(25);
25191                                internal(ios);
25192                                {
25193                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25194                                    std::string ex(str, iter.base());
25195                                    assert(ex == "+********0x9.32c05a44p+27");
25196                                    assert(ios.width() == 0);
25197                                }
25198                            }
25199                            ios.imbue(lg);
25200                            {
25201                                ios.width(0);
25202                                {
25203                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25204                                    std::string ex(str, iter.base());
25205                                    assert(ex == "+0x9;32c05a44p+27");
25206                                    assert(ios.width() == 0);
25207                                }
25208                                ios.width(25);
25209                                left(ios);
25210                                {
25211                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25212                                    std::string ex(str, iter.base());
25213                                    assert(ex == "+0x9;32c05a44p+27********");
25214                                    assert(ios.width() == 0);
25215                                }
25216                                ios.width(25);
25217                                right(ios);
25218                                {
25219                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25220                                    std::string ex(str, iter.base());
25221                                    assert(ex == "********+0x9;32c05a44p+27");
25222                                    assert(ios.width() == 0);
25223                                }
25224                                ios.width(25);
25225                                internal(ios);
25226                                {
25227                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25228                                    std::string ex(str, iter.base());
25229                                    assert(ex == "+********0x9;32c05a44p+27");
25230                                    assert(ios.width() == 0);
25231                                }
25232                            }
25233                        }
25234                        showpoint(ios);
25235                        {
25236                            ios.imbue(lc);
25237                            {
25238                                ios.width(0);
25239                                {
25240                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25241                                    std::string ex(str, iter.base());
25242                                    assert(ex == "+0x9.32c05a44p+27");
25243                                    assert(ios.width() == 0);
25244                                }
25245                                ios.width(25);
25246                                left(ios);
25247                                {
25248                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25249                                    std::string ex(str, iter.base());
25250                                    assert(ex == "+0x9.32c05a44p+27********");
25251                                    assert(ios.width() == 0);
25252                                }
25253                                ios.width(25);
25254                                right(ios);
25255                                {
25256                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25257                                    std::string ex(str, iter.base());
25258                                    assert(ex == "********+0x9.32c05a44p+27");
25259                                    assert(ios.width() == 0);
25260                                }
25261                                ios.width(25);
25262                                internal(ios);
25263                                {
25264                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25265                                    std::string ex(str, iter.base());
25266                                    assert(ex == "+********0x9.32c05a44p+27");
25267                                    assert(ios.width() == 0);
25268                                }
25269                            }
25270                            ios.imbue(lg);
25271                            {
25272                                ios.width(0);
25273                                {
25274                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25275                                    std::string ex(str, iter.base());
25276                                    assert(ex == "+0x9;32c05a44p+27");
25277                                    assert(ios.width() == 0);
25278                                }
25279                                ios.width(25);
25280                                left(ios);
25281                                {
25282                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25283                                    std::string ex(str, iter.base());
25284                                    assert(ex == "+0x9;32c05a44p+27********");
25285                                    assert(ios.width() == 0);
25286                                }
25287                                ios.width(25);
25288                                right(ios);
25289                                {
25290                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25291                                    std::string ex(str, iter.base());
25292                                    assert(ex == "********+0x9;32c05a44p+27");
25293                                    assert(ios.width() == 0);
25294                                }
25295                                ios.width(25);
25296                                internal(ios);
25297                                {
25298                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25299                                    std::string ex(str, iter.base());
25300                                    assert(ex == "+********0x9;32c05a44p+27");
25301                                    assert(ios.width() == 0);
25302                                }
25303                            }
25304                        }
25305                    }
25306                }
25307                uppercase(ios);
25308                {
25309                    noshowpos(ios);
25310                    {
25311                        noshowpoint(ios);
25312                        {
25313                            ios.imbue(lc);
25314                            {
25315                                ios.width(0);
25316                                {
25317                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25318                                    std::string ex(str, iter.base());
25319                                    assert(ex == "0X9.32C05A44P+27");
25320                                    assert(ios.width() == 0);
25321                                }
25322                                ios.width(25);
25323                                left(ios);
25324                                {
25325                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25326                                    std::string ex(str, iter.base());
25327                                    assert(ex == "0X9.32C05A44P+27*********");
25328                                    assert(ios.width() == 0);
25329                                }
25330                                ios.width(25);
25331                                right(ios);
25332                                {
25333                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25334                                    std::string ex(str, iter.base());
25335                                    assert(ex == "*********0X9.32C05A44P+27");
25336                                    assert(ios.width() == 0);
25337                                }
25338                                ios.width(25);
25339                                internal(ios);
25340                                {
25341                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25342                                    std::string ex(str, iter.base());
25343                                    assert(ex == "0X*********9.32C05A44P+27");
25344                                    assert(ios.width() == 0);
25345                                }
25346                            }
25347                            ios.imbue(lg);
25348                            {
25349                                ios.width(0);
25350                                {
25351                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25352                                    std::string ex(str, iter.base());
25353                                    assert(ex == "0X9;32C05A44P+27");
25354                                    assert(ios.width() == 0);
25355                                }
25356                                ios.width(25);
25357                                left(ios);
25358                                {
25359                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25360                                    std::string ex(str, iter.base());
25361                                    assert(ex == "0X9;32C05A44P+27*********");
25362                                    assert(ios.width() == 0);
25363                                }
25364                                ios.width(25);
25365                                right(ios);
25366                                {
25367                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25368                                    std::string ex(str, iter.base());
25369                                    assert(ex == "*********0X9;32C05A44P+27");
25370                                    assert(ios.width() == 0);
25371                                }
25372                                ios.width(25);
25373                                internal(ios);
25374                                {
25375                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25376                                    std::string ex(str, iter.base());
25377                                    assert(ex == "0X*********9;32C05A44P+27");
25378                                    assert(ios.width() == 0);
25379                                }
25380                            }
25381                        }
25382                        showpoint(ios);
25383                        {
25384                            ios.imbue(lc);
25385                            {
25386                                ios.width(0);
25387                                {
25388                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25389                                    std::string ex(str, iter.base());
25390                                    assert(ex == "0X9.32C05A44P+27");
25391                                    assert(ios.width() == 0);
25392                                }
25393                                ios.width(25);
25394                                left(ios);
25395                                {
25396                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25397                                    std::string ex(str, iter.base());
25398                                    assert(ex == "0X9.32C05A44P+27*********");
25399                                    assert(ios.width() == 0);
25400                                }
25401                                ios.width(25);
25402                                right(ios);
25403                                {
25404                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25405                                    std::string ex(str, iter.base());
25406                                    assert(ex == "*********0X9.32C05A44P+27");
25407                                    assert(ios.width() == 0);
25408                                }
25409                                ios.width(25);
25410                                internal(ios);
25411                                {
25412                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25413                                    std::string ex(str, iter.base());
25414                                    assert(ex == "0X*********9.32C05A44P+27");
25415                                    assert(ios.width() == 0);
25416                                }
25417                            }
25418                            ios.imbue(lg);
25419                            {
25420                                ios.width(0);
25421                                {
25422                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25423                                    std::string ex(str, iter.base());
25424                                    assert(ex == "0X9;32C05A44P+27");
25425                                    assert(ios.width() == 0);
25426                                }
25427                                ios.width(25);
25428                                left(ios);
25429                                {
25430                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25431                                    std::string ex(str, iter.base());
25432                                    assert(ex == "0X9;32C05A44P+27*********");
25433                                    assert(ios.width() == 0);
25434                                }
25435                                ios.width(25);
25436                                right(ios);
25437                                {
25438                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25439                                    std::string ex(str, iter.base());
25440                                    assert(ex == "*********0X9;32C05A44P+27");
25441                                    assert(ios.width() == 0);
25442                                }
25443                                ios.width(25);
25444                                internal(ios);
25445                                {
25446                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25447                                    std::string ex(str, iter.base());
25448                                    assert(ex == "0X*********9;32C05A44P+27");
25449                                    assert(ios.width() == 0);
25450                                }
25451                            }
25452                        }
25453                    }
25454                    showpos(ios);
25455                    {
25456                        noshowpoint(ios);
25457                        {
25458                            ios.imbue(lc);
25459                            {
25460                                ios.width(0);
25461                                {
25462                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25463                                    std::string ex(str, iter.base());
25464                                    assert(ex == "+0X9.32C05A44P+27");
25465                                    assert(ios.width() == 0);
25466                                }
25467                                ios.width(25);
25468                                left(ios);
25469                                {
25470                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25471                                    std::string ex(str, iter.base());
25472                                    assert(ex == "+0X9.32C05A44P+27********");
25473                                    assert(ios.width() == 0);
25474                                }
25475                                ios.width(25);
25476                                right(ios);
25477                                {
25478                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25479                                    std::string ex(str, iter.base());
25480                                    assert(ex == "********+0X9.32C05A44P+27");
25481                                    assert(ios.width() == 0);
25482                                }
25483                                ios.width(25);
25484                                internal(ios);
25485                                {
25486                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25487                                    std::string ex(str, iter.base());
25488                                    assert(ex == "+********0X9.32C05A44P+27");
25489                                    assert(ios.width() == 0);
25490                                }
25491                            }
25492                            ios.imbue(lg);
25493                            {
25494                                ios.width(0);
25495                                {
25496                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25497                                    std::string ex(str, iter.base());
25498                                    assert(ex == "+0X9;32C05A44P+27");
25499                                    assert(ios.width() == 0);
25500                                }
25501                                ios.width(25);
25502                                left(ios);
25503                                {
25504                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25505                                    std::string ex(str, iter.base());
25506                                    assert(ex == "+0X9;32C05A44P+27********");
25507                                    assert(ios.width() == 0);
25508                                }
25509                                ios.width(25);
25510                                right(ios);
25511                                {
25512                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25513                                    std::string ex(str, iter.base());
25514                                    assert(ex == "********+0X9;32C05A44P+27");
25515                                    assert(ios.width() == 0);
25516                                }
25517                                ios.width(25);
25518                                internal(ios);
25519                                {
25520                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25521                                    std::string ex(str, iter.base());
25522                                    assert(ex == "+********0X9;32C05A44P+27");
25523                                    assert(ios.width() == 0);
25524                                }
25525                            }
25526                        }
25527                        showpoint(ios);
25528                        {
25529                            ios.imbue(lc);
25530                            {
25531                                ios.width(0);
25532                                {
25533                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25534                                    std::string ex(str, iter.base());
25535                                    assert(ex == "+0X9.32C05A44P+27");
25536                                    assert(ios.width() == 0);
25537                                }
25538                                ios.width(25);
25539                                left(ios);
25540                                {
25541                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25542                                    std::string ex(str, iter.base());
25543                                    assert(ex == "+0X9.32C05A44P+27********");
25544                                    assert(ios.width() == 0);
25545                                }
25546                                ios.width(25);
25547                                right(ios);
25548                                {
25549                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25550                                    std::string ex(str, iter.base());
25551                                    assert(ex == "********+0X9.32C05A44P+27");
25552                                    assert(ios.width() == 0);
25553                                }
25554                                ios.width(25);
25555                                internal(ios);
25556                                {
25557                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25558                                    std::string ex(str, iter.base());
25559                                    assert(ex == "+********0X9.32C05A44P+27");
25560                                    assert(ios.width() == 0);
25561                                }
25562                            }
25563                            ios.imbue(lg);
25564                            {
25565                                ios.width(0);
25566                                {
25567                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25568                                    std::string ex(str, iter.base());
25569                                    assert(ex == "+0X9;32C05A44P+27");
25570                                    assert(ios.width() == 0);
25571                                }
25572                                ios.width(25);
25573                                left(ios);
25574                                {
25575                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25576                                    std::string ex(str, iter.base());
25577                                    assert(ex == "+0X9;32C05A44P+27********");
25578                                    assert(ios.width() == 0);
25579                                }
25580                                ios.width(25);
25581                                right(ios);
25582                                {
25583                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25584                                    std::string ex(str, iter.base());
25585                                    assert(ex == "********+0X9;32C05A44P+27");
25586                                    assert(ios.width() == 0);
25587                                }
25588                                ios.width(25);
25589                                internal(ios);
25590                                {
25591                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25592                                    std::string ex(str, iter.base());
25593                                    assert(ex == "+********0X9;32C05A44P+27");
25594                                    assert(ios.width() == 0);
25595                                }
25596                            }
25597                        }
25598                    }
25599                }
25600            }
25601            ios.precision(6);
25602            {
25603            }
25604            ios.precision(16);
25605            {
25606            }
25607            ios.precision(60);
25608            {
25609                nouppercase(ios);
25610                {
25611                    noshowpos(ios);
25612                    {
25613                        noshowpoint(ios);
25614                        {
25615                            ios.imbue(lc);
25616                            {
25617                                ios.width(0);
25618                                {
25619                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25620                                    std::string ex(str, iter.base());
25621                                    assert(ex == "0x9.32c05a44p+27");
25622                                    assert(ios.width() == 0);
25623                                }
25624                                ios.width(25);
25625                                left(ios);
25626                                {
25627                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25628                                    std::string ex(str, iter.base());
25629                                    assert(ex == "0x9.32c05a44p+27*********");
25630                                    assert(ios.width() == 0);
25631                                }
25632                                ios.width(25);
25633                                right(ios);
25634                                {
25635                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25636                                    std::string ex(str, iter.base());
25637                                    assert(ex == "*********0x9.32c05a44p+27");
25638                                    assert(ios.width() == 0);
25639                                }
25640                                ios.width(25);
25641                                internal(ios);
25642                                {
25643                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25644                                    std::string ex(str, iter.base());
25645                                    assert(ex == "0x*********9.32c05a44p+27");
25646                                    assert(ios.width() == 0);
25647                                }
25648                            }
25649                            ios.imbue(lg);
25650                            {
25651                                ios.width(0);
25652                                {
25653                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25654                                    std::string ex(str, iter.base());
25655                                    assert(ex == "0x9;32c05a44p+27");
25656                                    assert(ios.width() == 0);
25657                                }
25658                                ios.width(25);
25659                                left(ios);
25660                                {
25661                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25662                                    std::string ex(str, iter.base());
25663                                    assert(ex == "0x9;32c05a44p+27*********");
25664                                    assert(ios.width() == 0);
25665                                }
25666                                ios.width(25);
25667                                right(ios);
25668                                {
25669                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25670                                    std::string ex(str, iter.base());
25671                                    assert(ex == "*********0x9;32c05a44p+27");
25672                                    assert(ios.width() == 0);
25673                                }
25674                                ios.width(25);
25675                                internal(ios);
25676                                {
25677                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25678                                    std::string ex(str, iter.base());
25679                                    assert(ex == "0x*********9;32c05a44p+27");
25680                                    assert(ios.width() == 0);
25681                                }
25682                            }
25683                        }
25684                        showpoint(ios);
25685                        {
25686                            ios.imbue(lc);
25687                            {
25688                                ios.width(0);
25689                                {
25690                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25691                                    std::string ex(str, iter.base());
25692                                    assert(ex == "0x9.32c05a44p+27");
25693                                    assert(ios.width() == 0);
25694                                }
25695                                ios.width(25);
25696                                left(ios);
25697                                {
25698                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25699                                    std::string ex(str, iter.base());
25700                                    assert(ex == "0x9.32c05a44p+27*********");
25701                                    assert(ios.width() == 0);
25702                                }
25703                                ios.width(25);
25704                                right(ios);
25705                                {
25706                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25707                                    std::string ex(str, iter.base());
25708                                    assert(ex == "*********0x9.32c05a44p+27");
25709                                    assert(ios.width() == 0);
25710                                }
25711                                ios.width(25);
25712                                internal(ios);
25713                                {
25714                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25715                                    std::string ex(str, iter.base());
25716                                    assert(ex == "0x*********9.32c05a44p+27");
25717                                    assert(ios.width() == 0);
25718                                }
25719                            }
25720                            ios.imbue(lg);
25721                            {
25722                                ios.width(0);
25723                                {
25724                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25725                                    std::string ex(str, iter.base());
25726                                    assert(ex == "0x9;32c05a44p+27");
25727                                    assert(ios.width() == 0);
25728                                }
25729                                ios.width(25);
25730                                left(ios);
25731                                {
25732                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25733                                    std::string ex(str, iter.base());
25734                                    assert(ex == "0x9;32c05a44p+27*********");
25735                                    assert(ios.width() == 0);
25736                                }
25737                                ios.width(25);
25738                                right(ios);
25739                                {
25740                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25741                                    std::string ex(str, iter.base());
25742                                    assert(ex == "*********0x9;32c05a44p+27");
25743                                    assert(ios.width() == 0);
25744                                }
25745                                ios.width(25);
25746                                internal(ios);
25747                                {
25748                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25749                                    std::string ex(str, iter.base());
25750                                    assert(ex == "0x*********9;32c05a44p+27");
25751                                    assert(ios.width() == 0);
25752                                }
25753                            }
25754                        }
25755                    }
25756                    showpos(ios);
25757                    {
25758                        noshowpoint(ios);
25759                        {
25760                            ios.imbue(lc);
25761                            {
25762                                ios.width(0);
25763                                {
25764                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25765                                    std::string ex(str, iter.base());
25766                                    assert(ex == "+0x9.32c05a44p+27");
25767                                    assert(ios.width() == 0);
25768                                }
25769                                ios.width(25);
25770                                left(ios);
25771                                {
25772                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25773                                    std::string ex(str, iter.base());
25774                                    assert(ex == "+0x9.32c05a44p+27********");
25775                                    assert(ios.width() == 0);
25776                                }
25777                                ios.width(25);
25778                                right(ios);
25779                                {
25780                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25781                                    std::string ex(str, iter.base());
25782                                    assert(ex == "********+0x9.32c05a44p+27");
25783                                    assert(ios.width() == 0);
25784                                }
25785                                ios.width(25);
25786                                internal(ios);
25787                                {
25788                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25789                                    std::string ex(str, iter.base());
25790                                    assert(ex == "+********0x9.32c05a44p+27");
25791                                    assert(ios.width() == 0);
25792                                }
25793                            }
25794                            ios.imbue(lg);
25795                            {
25796                                ios.width(0);
25797                                {
25798                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25799                                    std::string ex(str, iter.base());
25800                                    assert(ex == "+0x9;32c05a44p+27");
25801                                    assert(ios.width() == 0);
25802                                }
25803                                ios.width(25);
25804                                left(ios);
25805                                {
25806                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25807                                    std::string ex(str, iter.base());
25808                                    assert(ex == "+0x9;32c05a44p+27********");
25809                                    assert(ios.width() == 0);
25810                                }
25811                                ios.width(25);
25812                                right(ios);
25813                                {
25814                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25815                                    std::string ex(str, iter.base());
25816                                    assert(ex == "********+0x9;32c05a44p+27");
25817                                    assert(ios.width() == 0);
25818                                }
25819                                ios.width(25);
25820                                internal(ios);
25821                                {
25822                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25823                                    std::string ex(str, iter.base());
25824                                    assert(ex == "+********0x9;32c05a44p+27");
25825                                    assert(ios.width() == 0);
25826                                }
25827                            }
25828                        }
25829                        showpoint(ios);
25830                        {
25831                            ios.imbue(lc);
25832                            {
25833                                ios.width(0);
25834                                {
25835                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25836                                    std::string ex(str, iter.base());
25837                                    assert(ex == "+0x9.32c05a44p+27");
25838                                    assert(ios.width() == 0);
25839                                }
25840                                ios.width(25);
25841                                left(ios);
25842                                {
25843                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25844                                    std::string ex(str, iter.base());
25845                                    assert(ex == "+0x9.32c05a44p+27********");
25846                                    assert(ios.width() == 0);
25847                                }
25848                                ios.width(25);
25849                                right(ios);
25850                                {
25851                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25852                                    std::string ex(str, iter.base());
25853                                    assert(ex == "********+0x9.32c05a44p+27");
25854                                    assert(ios.width() == 0);
25855                                }
25856                                ios.width(25);
25857                                internal(ios);
25858                                {
25859                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25860                                    std::string ex(str, iter.base());
25861                                    assert(ex == "+********0x9.32c05a44p+27");
25862                                    assert(ios.width() == 0);
25863                                }
25864                            }
25865                            ios.imbue(lg);
25866                            {
25867                                ios.width(0);
25868                                {
25869                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25870                                    std::string ex(str, iter.base());
25871                                    assert(ex == "+0x9;32c05a44p+27");
25872                                    assert(ios.width() == 0);
25873                                }
25874                                ios.width(25);
25875                                left(ios);
25876                                {
25877                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25878                                    std::string ex(str, iter.base());
25879                                    assert(ex == "+0x9;32c05a44p+27********");
25880                                    assert(ios.width() == 0);
25881                                }
25882                                ios.width(25);
25883                                right(ios);
25884                                {
25885                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25886                                    std::string ex(str, iter.base());
25887                                    assert(ex == "********+0x9;32c05a44p+27");
25888                                    assert(ios.width() == 0);
25889                                }
25890                                ios.width(25);
25891                                internal(ios);
25892                                {
25893                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25894                                    std::string ex(str, iter.base());
25895                                    assert(ex == "+********0x9;32c05a44p+27");
25896                                    assert(ios.width() == 0);
25897                                }
25898                            }
25899                        }
25900                    }
25901                }
25902                uppercase(ios);
25903                {
25904                    noshowpos(ios);
25905                    {
25906                        noshowpoint(ios);
25907                        {
25908                            ios.imbue(lc);
25909                            {
25910                                ios.width(0);
25911                                {
25912                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25913                                    std::string ex(str, iter.base());
25914                                    assert(ex == "0X9.32C05A44P+27");
25915                                    assert(ios.width() == 0);
25916                                }
25917                                ios.width(25);
25918                                left(ios);
25919                                {
25920                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25921                                    std::string ex(str, iter.base());
25922                                    assert(ex == "0X9.32C05A44P+27*********");
25923                                    assert(ios.width() == 0);
25924                                }
25925                                ios.width(25);
25926                                right(ios);
25927                                {
25928                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25929                                    std::string ex(str, iter.base());
25930                                    assert(ex == "*********0X9.32C05A44P+27");
25931                                    assert(ios.width() == 0);
25932                                }
25933                                ios.width(25);
25934                                internal(ios);
25935                                {
25936                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25937                                    std::string ex(str, iter.base());
25938                                    assert(ex == "0X*********9.32C05A44P+27");
25939                                    assert(ios.width() == 0);
25940                                }
25941                            }
25942                            ios.imbue(lg);
25943                            {
25944                                ios.width(0);
25945                                {
25946                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25947                                    std::string ex(str, iter.base());
25948                                    assert(ex == "0X9;32C05A44P+27");
25949                                    assert(ios.width() == 0);
25950                                }
25951                                ios.width(25);
25952                                left(ios);
25953                                {
25954                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25955                                    std::string ex(str, iter.base());
25956                                    assert(ex == "0X9;32C05A44P+27*********");
25957                                    assert(ios.width() == 0);
25958                                }
25959                                ios.width(25);
25960                                right(ios);
25961                                {
25962                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25963                                    std::string ex(str, iter.base());
25964                                    assert(ex == "*********0X9;32C05A44P+27");
25965                                    assert(ios.width() == 0);
25966                                }
25967                                ios.width(25);
25968                                internal(ios);
25969                                {
25970                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25971                                    std::string ex(str, iter.base());
25972                                    assert(ex == "0X*********9;32C05A44P+27");
25973                                    assert(ios.width() == 0);
25974                                }
25975                            }
25976                        }
25977                        showpoint(ios);
25978                        {
25979                            ios.imbue(lc);
25980                            {
25981                                ios.width(0);
25982                                {
25983                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25984                                    std::string ex(str, iter.base());
25985                                    assert(ex == "0X9.32C05A44P+27");
25986                                    assert(ios.width() == 0);
25987                                }
25988                                ios.width(25);
25989                                left(ios);
25990                                {
25991                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
25992                                    std::string ex(str, iter.base());
25993                                    assert(ex == "0X9.32C05A44P+27*********");
25994                                    assert(ios.width() == 0);
25995                                }
25996                                ios.width(25);
25997                                right(ios);
25998                                {
25999                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26000                                    std::string ex(str, iter.base());
26001                                    assert(ex == "*********0X9.32C05A44P+27");
26002                                    assert(ios.width() == 0);
26003                                }
26004                                ios.width(25);
26005                                internal(ios);
26006                                {
26007                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26008                                    std::string ex(str, iter.base());
26009                                    assert(ex == "0X*********9.32C05A44P+27");
26010                                    assert(ios.width() == 0);
26011                                }
26012                            }
26013                            ios.imbue(lg);
26014                            {
26015                                ios.width(0);
26016                                {
26017                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26018                                    std::string ex(str, iter.base());
26019                                    assert(ex == "0X9;32C05A44P+27");
26020                                    assert(ios.width() == 0);
26021                                }
26022                                ios.width(25);
26023                                left(ios);
26024                                {
26025                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26026                                    std::string ex(str, iter.base());
26027                                    assert(ex == "0X9;32C05A44P+27*********");
26028                                    assert(ios.width() == 0);
26029                                }
26030                                ios.width(25);
26031                                right(ios);
26032                                {
26033                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26034                                    std::string ex(str, iter.base());
26035                                    assert(ex == "*********0X9;32C05A44P+27");
26036                                    assert(ios.width() == 0);
26037                                }
26038                                ios.width(25);
26039                                internal(ios);
26040                                {
26041                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26042                                    std::string ex(str, iter.base());
26043                                    assert(ex == "0X*********9;32C05A44P+27");
26044                                    assert(ios.width() == 0);
26045                                }
26046                            }
26047                        }
26048                    }
26049                    showpos(ios);
26050                    {
26051                        noshowpoint(ios);
26052                        {
26053                            ios.imbue(lc);
26054                            {
26055                                ios.width(0);
26056                                {
26057                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26058                                    std::string ex(str, iter.base());
26059                                    assert(ex == "+0X9.32C05A44P+27");
26060                                    assert(ios.width() == 0);
26061                                }
26062                                ios.width(25);
26063                                left(ios);
26064                                {
26065                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26066                                    std::string ex(str, iter.base());
26067                                    assert(ex == "+0X9.32C05A44P+27********");
26068                                    assert(ios.width() == 0);
26069                                }
26070                                ios.width(25);
26071                                right(ios);
26072                                {
26073                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26074                                    std::string ex(str, iter.base());
26075                                    assert(ex == "********+0X9.32C05A44P+27");
26076                                    assert(ios.width() == 0);
26077                                }
26078                                ios.width(25);
26079                                internal(ios);
26080                                {
26081                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26082                                    std::string ex(str, iter.base());
26083                                    assert(ex == "+********0X9.32C05A44P+27");
26084                                    assert(ios.width() == 0);
26085                                }
26086                            }
26087                            ios.imbue(lg);
26088                            {
26089                                ios.width(0);
26090                                {
26091                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26092                                    std::string ex(str, iter.base());
26093                                    assert(ex == "+0X9;32C05A44P+27");
26094                                    assert(ios.width() == 0);
26095                                }
26096                                ios.width(25);
26097                                left(ios);
26098                                {
26099                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26100                                    std::string ex(str, iter.base());
26101                                    assert(ex == "+0X9;32C05A44P+27********");
26102                                    assert(ios.width() == 0);
26103                                }
26104                                ios.width(25);
26105                                right(ios);
26106                                {
26107                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26108                                    std::string ex(str, iter.base());
26109                                    assert(ex == "********+0X9;32C05A44P+27");
26110                                    assert(ios.width() == 0);
26111                                }
26112                                ios.width(25);
26113                                internal(ios);
26114                                {
26115                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26116                                    std::string ex(str, iter.base());
26117                                    assert(ex == "+********0X9;32C05A44P+27");
26118                                    assert(ios.width() == 0);
26119                                }
26120                            }
26121                        }
26122                        showpoint(ios);
26123                        {
26124                            ios.imbue(lc);
26125                            {
26126                                ios.width(0);
26127                                {
26128                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26129                                    std::string ex(str, iter.base());
26130                                    assert(ex == "+0X9.32C05A44P+27");
26131                                    assert(ios.width() == 0);
26132                                }
26133                                ios.width(25);
26134                                left(ios);
26135                                {
26136                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26137                                    std::string ex(str, iter.base());
26138                                    assert(ex == "+0X9.32C05A44P+27********");
26139                                    assert(ios.width() == 0);
26140                                }
26141                                ios.width(25);
26142                                right(ios);
26143                                {
26144                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26145                                    std::string ex(str, iter.base());
26146                                    assert(ex == "********+0X9.32C05A44P+27");
26147                                    assert(ios.width() == 0);
26148                                }
26149                                ios.width(25);
26150                                internal(ios);
26151                                {
26152                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26153                                    std::string ex(str, iter.base());
26154                                    assert(ex == "+********0X9.32C05A44P+27");
26155                                    assert(ios.width() == 0);
26156                                }
26157                            }
26158                            ios.imbue(lg);
26159                            {
26160                                ios.width(0);
26161                                {
26162                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26163                                    std::string ex(str, iter.base());
26164                                    assert(ex == "+0X9;32C05A44P+27");
26165                                    assert(ios.width() == 0);
26166                                }
26167                                ios.width(25);
26168                                left(ios);
26169                                {
26170                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26171                                    std::string ex(str, iter.base());
26172                                    assert(ex == "+0X9;32C05A44P+27********");
26173                                    assert(ios.width() == 0);
26174                                }
26175                                ios.width(25);
26176                                right(ios);
26177                                {
26178                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26179                                    std::string ex(str, iter.base());
26180                                    assert(ex == "********+0X9;32C05A44P+27");
26181                                    assert(ios.width() == 0);
26182                                }
26183                                ios.width(25);
26184                                internal(ios);
26185                                {
26186                                    iter = f.put(output_iterator<char*>(str), ios, '*', v);
26187                                    std::string ex(str, iter.base());
26188                                    assert(ex == "+********0X9;32C05A44P+27");
26189                                    assert(ios.width() == 0);
26190                                }
26191                            }
26192                        }
26193                    }
26194                }
26195            }
26196        }
26197    }
26198}
26199
26200int main()
26201{
26202    test1();
26203    test2();
26204    test3();
26205    test4();
26206    test5();
26207    test6();
26208    test7();
26209    test8();
26210    test9();
26211    test10();
26212    test11();
26213    test12();
26214    char str[200];
26215    output_iterator<char*> iter;
26216    std::locale lc = std::locale::classic();
26217    std::locale lg(lc, new my_numpunct);
26218    const my_facet f(1);
26219    {
26220        long double v = -INFINITY;
26221    }
26222    {
26223        long double v = std::nan("");
26224    }
26225
26226    {
26227        long double v = +0.;
26228    }
26229    {
26230        long double v = -INFINITY;
26231    }
26232    {
26233        long double v = std::nan("");
26234    }
26235    {
26236        long double v = -INFINITY;
26237    }
26238    {
26239        long double v = std::nan("");
26240    }
26241}
26242