Home | History | Annotate | Download | only in facet.num.put.members 
      1 //===----------------------------------------------------------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is dual licensed under the MIT and the University of Illinois Open
      6 // Source Licenses. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 
     10 // XFAIL: android
     11 
     12 // <locale>
     13 
     14 // class num_put<charT, OutputIterator>
     15 
     16 // iter_type put(iter_type s, ios_base& iob, char_type fill, long double v) const;
     17 
     18 // TODO GLIBC uses a different string for positive and negative NAN numbers.
     19 // XFAIL: linux-gnu
     20 
     21 #include <locale>
     22 #include <ios>
     23 #include <cassert>
     24 #include <streambuf>
     25 #include <cmath>
     26 #include "test_iterators.h"
     27 
     28 typedef std::num_put<char, output_iterator<char*> > F;
     29 
     30 class my_facet
     31     : public F
     32 {
     33 public:
     34     explicit my_facet(std::size_t refs = 0)
     35         : F(refs) {}
     36 };
     37 
     38 class my_numpunct
     39     : public std::numpunct<char>
     40 {
     41 public:
     42     my_numpunct() : std::numpunct<char>() {}
     43 
     44 protected:
     45     virtual char_type do_decimal_point() const {return ';';}
     46     virtual char_type do_thousands_sep() const {return '_';}
     47     virtual std::string do_grouping() const {return std::string("\1\2\3");}
     48 };
     49 
     50 void test1()
     51 {
     52     char str[200];
     53     output_iterator<char*> iter;
     54     std::locale lc = std::locale::classic();
     55     std::locale lg(lc, new my_numpunct);
     56     const my_facet f(1);
     57     {
     58         long double v = +0.;
     59         std::ios ios(0);
     60         // %g
     61         {
     62             ios.precision(0);
     63             {
     64                 nouppercase(ios);
     65                 {
     66                     noshowpos(ios);
     67                     {
     68                         noshowpoint(ios);
     69                         {
     70                             ios.imbue(lc);
     71                             {
     72                                 ios.width(0);
     73                                 {
     74                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
     75                                     std::string ex(str, iter.base());
     76                                     assert(ex == "0");
     77                                     assert(ios.width() == 0);
     78                                 }
     79                                 ios.width(25);
     80                                 left(ios);
     81                                 {
     82                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
     83                                     std::string ex(str, iter.base());
     84                                     assert(ex == "0************************");
     85                                     assert(ios.width() == 0);
     86                                 }
     87                                 ios.width(25);
     88                                 right(ios);
     89                                 {
     90                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
     91                                     std::string ex(str, iter.base());
     92                                     assert(ex == "************************0");
     93                                     assert(ios.width() == 0);
     94                                 }
     95                                 ios.width(25);
     96                                 internal(ios);
     97                                 {
     98                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
     99                                     std::string ex(str, iter.base());
    100                                     assert(ex == "************************0");
    101                                     assert(ios.width() == 0);
    102                                 }
    103                             }
    104                             ios.imbue(lg);
    105                             {
    106                                 ios.width(0);
    107                                 {
    108                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    109                                     std::string ex(str, iter.base());
    110                                     assert(ex == "0");
    111                                     assert(ios.width() == 0);
    112                                 }
    113                                 ios.width(25);
    114                                 left(ios);
    115                                 {
    116                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    117                                     std::string ex(str, iter.base());
    118                                     assert(ex == "0************************");
    119                                     assert(ios.width() == 0);
    120                                 }
    121                                 ios.width(25);
    122                                 right(ios);
    123                                 {
    124                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    125                                     std::string ex(str, iter.base());
    126                                     assert(ex == "************************0");
    127                                     assert(ios.width() == 0);
    128                                 }
    129                                 ios.width(25);
    130                                 internal(ios);
    131                                 {
    132                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    133                                     std::string ex(str, iter.base());
    134                                     assert(ex == "************************0");
    135                                     assert(ios.width() == 0);
    136                                 }
    137                             }
    138                         }
    139                         showpoint(ios);
    140                         {
    141                             ios.imbue(lc);
    142                             {
    143                                 ios.width(0);
    144                                 {
    145                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    146                                     std::string ex(str, iter.base());
    147                                     assert(ex == "0.");
    148                                     assert(ios.width() == 0);
    149                                 }
    150                                 ios.width(25);
    151                                 left(ios);
    152                                 {
    153                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    154                                     std::string ex(str, iter.base());
    155                                     assert(ex == "0.***********************");
    156                                     assert(ios.width() == 0);
    157                                 }
    158                                 ios.width(25);
    159                                 right(ios);
    160                                 {
    161                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    162                                     std::string ex(str, iter.base());
    163                                     assert(ex == "***********************0.");
    164                                     assert(ios.width() == 0);
    165                                 }
    166                                 ios.width(25);
    167                                 internal(ios);
    168                                 {
    169                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    170                                     std::string ex(str, iter.base());
    171                                     assert(ex == "***********************0.");
    172                                     assert(ios.width() == 0);
    173                                 }
    174                             }
    175                             ios.imbue(lg);
    176                             {
    177                                 ios.width(0);
    178                                 {
    179                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    180                                     std::string ex(str, iter.base());
    181                                     assert(ex == "0;");
    182                                     assert(ios.width() == 0);
    183                                 }
    184                                 ios.width(25);
    185                                 left(ios);
    186                                 {
    187                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    188                                     std::string ex(str, iter.base());
    189                                     assert(ex == "0;***********************");
    190                                     assert(ios.width() == 0);
    191                                 }
    192                                 ios.width(25);
    193                                 right(ios);
    194                                 {
    195                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    196                                     std::string ex(str, iter.base());
    197                                     assert(ex == "***********************0;");
    198                                     assert(ios.width() == 0);
    199                                 }
    200                                 ios.width(25);
    201                                 internal(ios);
    202                                 {
    203                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    204                                     std::string ex(str, iter.base());
    205                                     assert(ex == "***********************0;");
    206                                     assert(ios.width() == 0);
    207                                 }
    208                             }
    209                         }
    210                     }
    211                     showpos(ios);
    212                     {
    213                         noshowpoint(ios);
    214                         {
    215                             ios.imbue(lc);
    216                             {
    217                                 ios.width(0);
    218                                 {
    219                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    220                                     std::string ex(str, iter.base());
    221                                     assert(ex == "+0");
    222                                     assert(ios.width() == 0);
    223                                 }
    224                                 ios.width(25);
    225                                 left(ios);
    226                                 {
    227                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    228                                     std::string ex(str, iter.base());
    229                                     assert(ex == "+0***********************");
    230                                     assert(ios.width() == 0);
    231                                 }
    232                                 ios.width(25);
    233                                 right(ios);
    234                                 {
    235                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    236                                     std::string ex(str, iter.base());
    237                                     assert(ex == "***********************+0");
    238                                     assert(ios.width() == 0);
    239                                 }
    240                                 ios.width(25);
    241                                 internal(ios);
    242                                 {
    243                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    244                                     std::string ex(str, iter.base());
    245                                     assert(ex == "+***********************0");
    246                                     assert(ios.width() == 0);
    247                                 }
    248                             }
    249                             ios.imbue(lg);
    250                             {
    251                                 ios.width(0);
    252                                 {
    253                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    254                                     std::string ex(str, iter.base());
    255                                     assert(ex == "+0");
    256                                     assert(ios.width() == 0);
    257                                 }
    258                                 ios.width(25);
    259                                 left(ios);
    260                                 {
    261                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    262                                     std::string ex(str, iter.base());
    263                                     assert(ex == "+0***********************");
    264                                     assert(ios.width() == 0);
    265                                 }
    266                                 ios.width(25);
    267                                 right(ios);
    268                                 {
    269                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    270                                     std::string ex(str, iter.base());
    271                                     assert(ex == "***********************+0");
    272                                     assert(ios.width() == 0);
    273                                 }
    274                                 ios.width(25);
    275                                 internal(ios);
    276                                 {
    277                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    278                                     std::string ex(str, iter.base());
    279                                     assert(ex == "+***********************0");
    280                                     assert(ios.width() == 0);
    281                                 }
    282                             }
    283                         }
    284                         showpoint(ios);
    285                         {
    286                             ios.imbue(lc);
    287                             {
    288                                 ios.width(0);
    289                                 {
    290                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    291                                     std::string ex(str, iter.base());
    292                                     assert(ex == "+0.");
    293                                     assert(ios.width() == 0);
    294                                 }
    295                                 ios.width(25);
    296                                 left(ios);
    297                                 {
    298                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    299                                     std::string ex(str, iter.base());
    300                                     assert(ex == "+0.**********************");
    301                                     assert(ios.width() == 0);
    302                                 }
    303                                 ios.width(25);
    304                                 right(ios);
    305                                 {
    306                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    307                                     std::string ex(str, iter.base());
    308                                     assert(ex == "**********************+0.");
    309                                     assert(ios.width() == 0);
    310                                 }
    311                                 ios.width(25);
    312                                 internal(ios);
    313                                 {
    314                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    315                                     std::string ex(str, iter.base());
    316                                     assert(ex == "+**********************0.");
    317                                     assert(ios.width() == 0);
    318                                 }
    319                             }
    320                             ios.imbue(lg);
    321                             {
    322                                 ios.width(0);
    323                                 {
    324                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    325                                     std::string ex(str, iter.base());
    326                                     assert(ex == "+0;");
    327                                     assert(ios.width() == 0);
    328                                 }
    329                                 ios.width(25);
    330                                 left(ios);
    331                                 {
    332                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    333                                     std::string ex(str, iter.base());
    334                                     assert(ex == "+0;**********************");
    335                                     assert(ios.width() == 0);
    336                                 }
    337                                 ios.width(25);
    338                                 right(ios);
    339                                 {
    340                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    341                                     std::string ex(str, iter.base());
    342                                     assert(ex == "**********************+0;");
    343                                     assert(ios.width() == 0);
    344                                 }
    345                                 ios.width(25);
    346                                 internal(ios);
    347                                 {
    348                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    349                                     std::string ex(str, iter.base());
    350                                     assert(ex == "+**********************0;");
    351                                     assert(ios.width() == 0);
    352                                 }
    353                             }
    354                         }
    355                     }
    356                 }
    357                 uppercase(ios);
    358                 {
    359                     noshowpos(ios);
    360                     {
    361                         noshowpoint(ios);
    362                         {
    363                             ios.imbue(lc);
    364                             {
    365                                 ios.width(0);
    366                                 {
    367                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    368                                     std::string ex(str, iter.base());
    369                                     assert(ex == "0");
    370                                     assert(ios.width() == 0);
    371                                 }
    372                                 ios.width(25);
    373                                 left(ios);
    374                                 {
    375                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    376                                     std::string ex(str, iter.base());
    377                                     assert(ex == "0************************");
    378                                     assert(ios.width() == 0);
    379                                 }
    380                                 ios.width(25);
    381                                 right(ios);
    382                                 {
    383                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    384                                     std::string ex(str, iter.base());
    385                                     assert(ex == "************************0");
    386                                     assert(ios.width() == 0);
    387                                 }
    388                                 ios.width(25);
    389                                 internal(ios);
    390                                 {
    391                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    392                                     std::string ex(str, iter.base());
    393                                     assert(ex == "************************0");
    394                                     assert(ios.width() == 0);
    395                                 }
    396                             }
    397                             ios.imbue(lg);
    398                             {
    399                                 ios.width(0);
    400                                 {
    401                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    402                                     std::string ex(str, iter.base());
    403                                     assert(ex == "0");
    404                                     assert(ios.width() == 0);
    405                                 }
    406                                 ios.width(25);
    407                                 left(ios);
    408                                 {
    409                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    410                                     std::string ex(str, iter.base());
    411                                     assert(ex == "0************************");
    412                                     assert(ios.width() == 0);
    413                                 }
    414                                 ios.width(25);
    415                                 right(ios);
    416                                 {
    417                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    418                                     std::string ex(str, iter.base());
    419                                     assert(ex == "************************0");
    420                                     assert(ios.width() == 0);
    421                                 }
    422                                 ios.width(25);
    423                                 internal(ios);
    424                                 {
    425                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    426                                     std::string ex(str, iter.base());
    427                                     assert(ex == "************************0");
    428                                     assert(ios.width() == 0);
    429                                 }
    430                             }
    431                         }
    432                         showpoint(ios);
    433                         {
    434                             ios.imbue(lc);
    435                             {
    436                                 ios.width(0);
    437                                 {
    438                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    439                                     std::string ex(str, iter.base());
    440                                     assert(ex == "0.");
    441                                     assert(ios.width() == 0);
    442                                 }
    443                                 ios.width(25);
    444                                 left(ios);
    445                                 {
    446                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    447                                     std::string ex(str, iter.base());
    448                                     assert(ex == "0.***********************");
    449                                     assert(ios.width() == 0);
    450                                 }
    451                                 ios.width(25);
    452                                 right(ios);
    453                                 {
    454                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    455                                     std::string ex(str, iter.base());
    456                                     assert(ex == "***********************0.");
    457                                     assert(ios.width() == 0);
    458                                 }
    459                                 ios.width(25);
    460                                 internal(ios);
    461                                 {
    462                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    463                                     std::string ex(str, iter.base());
    464                                     assert(ex == "***********************0.");
    465                                     assert(ios.width() == 0);
    466                                 }
    467                             }
    468                             ios.imbue(lg);
    469                             {
    470                                 ios.width(0);
    471                                 {
    472                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    473                                     std::string ex(str, iter.base());
    474                                     assert(ex == "0;");
    475                                     assert(ios.width() == 0);
    476                                 }
    477                                 ios.width(25);
    478                                 left(ios);
    479                                 {
    480                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    481                                     std::string ex(str, iter.base());
    482                                     assert(ex == "0;***********************");
    483                                     assert(ios.width() == 0);
    484                                 }
    485                                 ios.width(25);
    486                                 right(ios);
    487                                 {
    488                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    489                                     std::string ex(str, iter.base());
    490                                     assert(ex == "***********************0;");
    491                                     assert(ios.width() == 0);
    492                                 }
    493                                 ios.width(25);
    494                                 internal(ios);
    495                                 {
    496                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    497                                     std::string ex(str, iter.base());
    498                                     assert(ex == "***********************0;");
    499                                     assert(ios.width() == 0);
    500                                 }
    501                             }
    502                         }
    503                     }
    504                     showpos(ios);
    505                     {
    506                         noshowpoint(ios);
    507                         {
    508                             ios.imbue(lc);
    509                             {
    510                                 ios.width(0);
    511                                 {
    512                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    513                                     std::string ex(str, iter.base());
    514                                     assert(ex == "+0");
    515                                     assert(ios.width() == 0);
    516                                 }
    517                                 ios.width(25);
    518                                 left(ios);
    519                                 {
    520                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    521                                     std::string ex(str, iter.base());
    522                                     assert(ex == "+0***********************");
    523                                     assert(ios.width() == 0);
    524                                 }
    525                                 ios.width(25);
    526                                 right(ios);
    527                                 {
    528                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    529                                     std::string ex(str, iter.base());
    530                                     assert(ex == "***********************+0");
    531                                     assert(ios.width() == 0);
    532                                 }
    533                                 ios.width(25);
    534                                 internal(ios);
    535                                 {
    536                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    537                                     std::string ex(str, iter.base());
    538                                     assert(ex == "+***********************0");
    539                                     assert(ios.width() == 0);
    540                                 }
    541                             }
    542                             ios.imbue(lg);
    543                             {
    544                                 ios.width(0);
    545                                 {
    546                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    547                                     std::string ex(str, iter.base());
    548                                     assert(ex == "+0");
    549                                     assert(ios.width() == 0);
    550                                 }
    551                                 ios.width(25);
    552                                 left(ios);
    553                                 {
    554                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    555                                     std::string ex(str, iter.base());
    556                                     assert(ex == "+0***********************");
    557                                     assert(ios.width() == 0);
    558                                 }
    559                                 ios.width(25);
    560                                 right(ios);
    561                                 {
    562                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    563                                     std::string ex(str, iter.base());
    564                                     assert(ex == "***********************+0");
    565                                     assert(ios.width() == 0);
    566                                 }
    567                                 ios.width(25);
    568                                 internal(ios);
    569                                 {
    570                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    571                                     std::string ex(str, iter.base());
    572                                     assert(ex == "+***********************0");
    573                                     assert(ios.width() == 0);
    574                                 }
    575                             }
    576                         }
    577                         showpoint(ios);
    578                         {
    579                             ios.imbue(lc);
    580                             {
    581                                 ios.width(0);
    582                                 {
    583                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    584                                     std::string ex(str, iter.base());
    585                                     assert(ex == "+0.");
    586                                     assert(ios.width() == 0);
    587                                 }
    588                                 ios.width(25);
    589                                 left(ios);
    590                                 {
    591                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    592                                     std::string ex(str, iter.base());
    593                                     assert(ex == "+0.**********************");
    594                                     assert(ios.width() == 0);
    595                                 }
    596                                 ios.width(25);
    597                                 right(ios);
    598                                 {
    599                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    600                                     std::string ex(str, iter.base());
    601                                     assert(ex == "**********************+0.");
    602                                     assert(ios.width() == 0);
    603                                 }
    604                                 ios.width(25);
    605                                 internal(ios);
    606                                 {
    607                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    608                                     std::string ex(str, iter.base());
    609                                     assert(ex == "+**********************0.");
    610                                     assert(ios.width() == 0);
    611                                 }
    612                             }
    613                             ios.imbue(lg);
    614                             {
    615                                 ios.width(0);
    616                                 {
    617                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    618                                     std::string ex(str, iter.base());
    619                                     assert(ex == "+0;");
    620                                     assert(ios.width() == 0);
    621                                 }
    622                                 ios.width(25);
    623                                 left(ios);
    624                                 {
    625                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    626                                     std::string ex(str, iter.base());
    627                                     assert(ex == "+0;**********************");
    628                                     assert(ios.width() == 0);
    629                                 }
    630                                 ios.width(25);
    631                                 right(ios);
    632                                 {
    633                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    634                                     std::string ex(str, iter.base());
    635                                     assert(ex == "**********************+0;");
    636                                     assert(ios.width() == 0);
    637                                 }
    638                                 ios.width(25);
    639                                 internal(ios);
    640                                 {
    641                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    642                                     std::string ex(str, iter.base());
    643                                     assert(ex == "+**********************0;");
    644                                     assert(ios.width() == 0);
    645                                 }
    646                             }
    647                         }
    648                     }
    649                 }
    650             }
    651             ios.precision(1);
    652             {
    653                 nouppercase(ios);
    654                 {
    655                     noshowpos(ios);
    656                     {
    657                         noshowpoint(ios);
    658                         {
    659                             ios.imbue(lc);
    660                             {
    661                                 ios.width(0);
    662                                 {
    663                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    664                                     std::string ex(str, iter.base());
    665                                     assert(ex == "0");
    666                                     assert(ios.width() == 0);
    667                                 }
    668                                 ios.width(25);
    669                                 left(ios);
    670                                 {
    671                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    672                                     std::string ex(str, iter.base());
    673                                     assert(ex == "0************************");
    674                                     assert(ios.width() == 0);
    675                                 }
    676                                 ios.width(25);
    677                                 right(ios);
    678                                 {
    679                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    680                                     std::string ex(str, iter.base());
    681                                     assert(ex == "************************0");
    682                                     assert(ios.width() == 0);
    683                                 }
    684                                 ios.width(25);
    685                                 internal(ios);
    686                                 {
    687                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    688                                     std::string ex(str, iter.base());
    689                                     assert(ex == "************************0");
    690                                     assert(ios.width() == 0);
    691                                 }
    692                             }
    693                             ios.imbue(lg);
    694                             {
    695                                 ios.width(0);
    696                                 {
    697                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    698                                     std::string ex(str, iter.base());
    699                                     assert(ex == "0");
    700                                     assert(ios.width() == 0);
    701                                 }
    702                                 ios.width(25);
    703                                 left(ios);
    704                                 {
    705                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    706                                     std::string ex(str, iter.base());
    707                                     assert(ex == "0************************");
    708                                     assert(ios.width() == 0);
    709                                 }
    710                                 ios.width(25);
    711                                 right(ios);
    712                                 {
    713                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    714                                     std::string ex(str, iter.base());
    715                                     assert(ex == "************************0");
    716                                     assert(ios.width() == 0);
    717                                 }
    718                                 ios.width(25);
    719                                 internal(ios);
    720                                 {
    721                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    722                                     std::string ex(str, iter.base());
    723                                     assert(ex == "************************0");
    724                                     assert(ios.width() == 0);
    725                                 }
    726                             }
    727                         }
    728                         showpoint(ios);
    729                         {
    730                             ios.imbue(lc);
    731                             {
    732                                 ios.width(0);
    733                                 {
    734                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    735                                     std::string ex(str, iter.base());
    736                                     assert(ex == "0.");
    737                                     assert(ios.width() == 0);
    738                                 }
    739                                 ios.width(25);
    740                                 left(ios);
    741                                 {
    742                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    743                                     std::string ex(str, iter.base());
    744                                     assert(ex == "0.***********************");
    745                                     assert(ios.width() == 0);
    746                                 }
    747                                 ios.width(25);
    748                                 right(ios);
    749                                 {
    750                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    751                                     std::string ex(str, iter.base());
    752                                     assert(ex == "***********************0.");
    753                                     assert(ios.width() == 0);
    754                                 }
    755                                 ios.width(25);
    756                                 internal(ios);
    757                                 {
    758                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    759                                     std::string ex(str, iter.base());
    760                                     assert(ex == "***********************0.");
    761                                     assert(ios.width() == 0);
    762                                 }
    763                             }
    764                             ios.imbue(lg);
    765                             {
    766                                 ios.width(0);
    767                                 {
    768                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    769                                     std::string ex(str, iter.base());
    770                                     assert(ex == "0;");
    771                                     assert(ios.width() == 0);
    772                                 }
    773                                 ios.width(25);
    774                                 left(ios);
    775                                 {
    776                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    777                                     std::string ex(str, iter.base());
    778                                     assert(ex == "0;***********************");
    779                                     assert(ios.width() == 0);
    780                                 }
    781                                 ios.width(25);
    782                                 right(ios);
    783                                 {
    784                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    785                                     std::string ex(str, iter.base());
    786                                     assert(ex == "***********************0;");
    787                                     assert(ios.width() == 0);
    788                                 }
    789                                 ios.width(25);
    790                                 internal(ios);
    791                                 {
    792                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    793                                     std::string ex(str, iter.base());
    794                                     assert(ex == "***********************0;");
    795                                     assert(ios.width() == 0);
    796                                 }
    797                             }
    798                         }
    799                     }
    800                     showpos(ios);
    801                     {
    802                         noshowpoint(ios);
    803                         {
    804                             ios.imbue(lc);
    805                             {
    806                                 ios.width(0);
    807                                 {
    808                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    809                                     std::string ex(str, iter.base());
    810                                     assert(ex == "+0");
    811                                     assert(ios.width() == 0);
    812                                 }
    813                                 ios.width(25);
    814                                 left(ios);
    815                                 {
    816                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    817                                     std::string ex(str, iter.base());
    818                                     assert(ex == "+0***********************");
    819                                     assert(ios.width() == 0);
    820                                 }
    821                                 ios.width(25);
    822                                 right(ios);
    823                                 {
    824                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    825                                     std::string ex(str, iter.base());
    826                                     assert(ex == "***********************+0");
    827                                     assert(ios.width() == 0);
    828                                 }
    829                                 ios.width(25);
    830                                 internal(ios);
    831                                 {
    832                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    833                                     std::string ex(str, iter.base());
    834                                     assert(ex == "+***********************0");
    835                                     assert(ios.width() == 0);
    836                                 }
    837                             }
    838                             ios.imbue(lg);
    839                             {
    840                                 ios.width(0);
    841                                 {
    842                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    843                                     std::string ex(str, iter.base());
    844                                     assert(ex == "+0");
    845                                     assert(ios.width() == 0);
    846                                 }
    847                                 ios.width(25);
    848                                 left(ios);
    849                                 {
    850                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    851                                     std::string ex(str, iter.base());
    852                                     assert(ex == "+0***********************");
    853                                     assert(ios.width() == 0);
    854                                 }
    855                                 ios.width(25);
    856                                 right(ios);
    857                                 {
    858                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    859                                     std::string ex(str, iter.base());
    860                                     assert(ex == "***********************+0");
    861                                     assert(ios.width() == 0);
    862                                 }
    863                                 ios.width(25);
    864                                 internal(ios);
    865                                 {
    866                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    867                                     std::string ex(str, iter.base());
    868                                     assert(ex == "+***********************0");
    869                                     assert(ios.width() == 0);
    870                                 }
    871                             }
    872                         }
    873                         showpoint(ios);
    874                         {
    875                             ios.imbue(lc);
    876                             {
    877                                 ios.width(0);
    878                                 {
    879                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    880                                     std::string ex(str, iter.base());
    881                                     assert(ex == "+0.");
    882                                     assert(ios.width() == 0);
    883                                 }
    884                                 ios.width(25);
    885                                 left(ios);
    886                                 {
    887                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    888                                     std::string ex(str, iter.base());
    889                                     assert(ex == "+0.**********************");
    890                                     assert(ios.width() == 0);
    891                                 }
    892                                 ios.width(25);
    893                                 right(ios);
    894                                 {
    895                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    896                                     std::string ex(str, iter.base());
    897                                     assert(ex == "**********************+0.");
    898                                     assert(ios.width() == 0);
    899                                 }
    900                                 ios.width(25);
    901                                 internal(ios);
    902                                 {
    903                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    904                                     std::string ex(str, iter.base());
    905                                     assert(ex == "+**********************0.");
    906                                     assert(ios.width() == 0);
    907                                 }
    908                             }
    909                             ios.imbue(lg);
    910                             {
    911                                 ios.width(0);
    912                                 {
    913                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    914                                     std::string ex(str, iter.base());
    915                                     assert(ex == "+0;");
    916                                     assert(ios.width() == 0);
    917                                 }
    918                                 ios.width(25);
    919                                 left(ios);
    920                                 {
    921                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    922                                     std::string ex(str, iter.base());
    923                                     assert(ex == "+0;**********************");
    924                                     assert(ios.width() == 0);
    925                                 }
    926                                 ios.width(25);
    927                                 right(ios);
    928                                 {
    929                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    930                                     std::string ex(str, iter.base());
    931                                     assert(ex == "**********************+0;");
    932                                     assert(ios.width() == 0);
    933                                 }
    934                                 ios.width(25);
    935                                 internal(ios);
    936                                 {
    937                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    938                                     std::string ex(str, iter.base());
    939                                     assert(ex == "+**********************0;");
    940                                     assert(ios.width() == 0);
    941                                 }
    942                             }
    943                         }
    944                     }
    945                 }
    946                 uppercase(ios);
    947                 {
    948                     noshowpos(ios);
    949                     {
    950                         noshowpoint(ios);
    951                         {
    952                             ios.imbue(lc);
    953                             {
    954                                 ios.width(0);
    955                                 {
    956                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    957                                     std::string ex(str, iter.base());
    958                                     assert(ex == "0");
    959                                     assert(ios.width() == 0);
    960                                 }
    961                                 ios.width(25);
    962                                 left(ios);
    963                                 {
    964                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    965                                     std::string ex(str, iter.base());
    966                                     assert(ex == "0************************");
    967                                     assert(ios.width() == 0);
    968                                 }
    969                                 ios.width(25);
    970                                 right(ios);
    971                                 {
    972                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    973                                     std::string ex(str, iter.base());
    974                                     assert(ex == "************************0");
    975                                     assert(ios.width() == 0);
    976                                 }
    977                                 ios.width(25);
    978                                 internal(ios);
    979                                 {
    980                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    981                                     std::string ex(str, iter.base());
    982                                     assert(ex == "************************0");
    983                                     assert(ios.width() == 0);
    984                                 }
    985                             }
    986                             ios.imbue(lg);
    987                             {
    988                                 ios.width(0);
    989                                 {
    990                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    991                                     std::string ex(str, iter.base());
    992                                     assert(ex == "0");
    993                                     assert(ios.width() == 0);
    994                                 }
    995                                 ios.width(25);
    996                                 left(ios);
    997                                 {
    998                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    999                                     std::string ex(str, iter.base());
   1000                                     assert(ex == "0************************");
   1001                                     assert(ios.width() == 0);
   1002                                 }
   1003                                 ios.width(25);
   1004                                 right(ios);
   1005                                 {
   1006                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1007                                     std::string ex(str, iter.base());
   1008                                     assert(ex == "************************0");
   1009                                     assert(ios.width() == 0);
   1010                                 }
   1011                                 ios.width(25);
   1012                                 internal(ios);
   1013                                 {
   1014                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1015                                     std::string ex(str, iter.base());
   1016                                     assert(ex == "************************0");
   1017                                     assert(ios.width() == 0);
   1018                                 }
   1019                             }
   1020                         }
   1021                         showpoint(ios);
   1022                         {
   1023                             ios.imbue(lc);
   1024                             {
   1025                                 ios.width(0);
   1026                                 {
   1027                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1028                                     std::string ex(str, iter.base());
   1029                                     assert(ex == "0.");
   1030                                     assert(ios.width() == 0);
   1031                                 }
   1032                                 ios.width(25);
   1033                                 left(ios);
   1034                                 {
   1035                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1036                                     std::string ex(str, iter.base());
   1037                                     assert(ex == "0.***********************");
   1038                                     assert(ios.width() == 0);
   1039                                 }
   1040                                 ios.width(25);
   1041                                 right(ios);
   1042                                 {
   1043                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1044                                     std::string ex(str, iter.base());
   1045                                     assert(ex == "***********************0.");
   1046                                     assert(ios.width() == 0);
   1047                                 }
   1048                                 ios.width(25);
   1049                                 internal(ios);
   1050                                 {
   1051                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1052                                     std::string ex(str, iter.base());
   1053                                     assert(ex == "***********************0.");
   1054                                     assert(ios.width() == 0);
   1055                                 }
   1056                             }
   1057                             ios.imbue(lg);
   1058                             {
   1059                                 ios.width(0);
   1060                                 {
   1061                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1062                                     std::string ex(str, iter.base());
   1063                                     assert(ex == "0;");
   1064                                     assert(ios.width() == 0);
   1065                                 }
   1066                                 ios.width(25);
   1067                                 left(ios);
   1068                                 {
   1069                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1070                                     std::string ex(str, iter.base());
   1071                                     assert(ex == "0;***********************");
   1072                                     assert(ios.width() == 0);
   1073                                 }
   1074                                 ios.width(25);
   1075                                 right(ios);
   1076                                 {
   1077                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1078                                     std::string ex(str, iter.base());
   1079                                     assert(ex == "***********************0;");
   1080                                     assert(ios.width() == 0);
   1081                                 }
   1082                                 ios.width(25);
   1083                                 internal(ios);
   1084                                 {
   1085                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1086                                     std::string ex(str, iter.base());
   1087                                     assert(ex == "***********************0;");
   1088                                     assert(ios.width() == 0);
   1089                                 }
   1090                             }
   1091                         }
   1092                     }
   1093                     showpos(ios);
   1094                     {
   1095                         noshowpoint(ios);
   1096                         {
   1097                             ios.imbue(lc);
   1098                             {
   1099                                 ios.width(0);
   1100                                 {
   1101                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1102                                     std::string ex(str, iter.base());
   1103                                     assert(ex == "+0");
   1104                                     assert(ios.width() == 0);
   1105                                 }
   1106                                 ios.width(25);
   1107                                 left(ios);
   1108                                 {
   1109                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1110                                     std::string ex(str, iter.base());
   1111                                     assert(ex == "+0***********************");
   1112                                     assert(ios.width() == 0);
   1113                                 }
   1114                                 ios.width(25);
   1115                                 right(ios);
   1116                                 {
   1117                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1118                                     std::string ex(str, iter.base());
   1119                                     assert(ex == "***********************+0");
   1120                                     assert(ios.width() == 0);
   1121                                 }
   1122                                 ios.width(25);
   1123                                 internal(ios);
   1124                                 {
   1125                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1126                                     std::string ex(str, iter.base());
   1127                                     assert(ex == "+***********************0");
   1128                                     assert(ios.width() == 0);
   1129                                 }
   1130                             }
   1131                             ios.imbue(lg);
   1132                             {
   1133                                 ios.width(0);
   1134                                 {
   1135                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1136                                     std::string ex(str, iter.base());
   1137                                     assert(ex == "+0");
   1138                                     assert(ios.width() == 0);
   1139                                 }
   1140                                 ios.width(25);
   1141                                 left(ios);
   1142                                 {
   1143                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1144                                     std::string ex(str, iter.base());
   1145                                     assert(ex == "+0***********************");
   1146                                     assert(ios.width() == 0);
   1147                                 }
   1148                                 ios.width(25);
   1149                                 right(ios);
   1150                                 {
   1151                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1152                                     std::string ex(str, iter.base());
   1153                                     assert(ex == "***********************+0");
   1154                                     assert(ios.width() == 0);
   1155                                 }
   1156                                 ios.width(25);
   1157                                 internal(ios);
   1158                                 {
   1159                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1160                                     std::string ex(str, iter.base());
   1161                                     assert(ex == "+***********************0");
   1162                                     assert(ios.width() == 0);
   1163                                 }
   1164                             }
   1165                         }
   1166                         showpoint(ios);
   1167                         {
   1168                             ios.imbue(lc);
   1169                             {
   1170                                 ios.width(0);
   1171                                 {
   1172                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1173                                     std::string ex(str, iter.base());
   1174                                     assert(ex == "+0.");
   1175                                     assert(ios.width() == 0);
   1176                                 }
   1177                                 ios.width(25);
   1178                                 left(ios);
   1179                                 {
   1180                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1181                                     std::string ex(str, iter.base());
   1182                                     assert(ex == "+0.**********************");
   1183                                     assert(ios.width() == 0);
   1184                                 }
   1185                                 ios.width(25);
   1186                                 right(ios);
   1187                                 {
   1188                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1189                                     std::string ex(str, iter.base());
   1190                                     assert(ex == "**********************+0.");
   1191                                     assert(ios.width() == 0);
   1192                                 }
   1193                                 ios.width(25);
   1194                                 internal(ios);
   1195                                 {
   1196                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1197                                     std::string ex(str, iter.base());
   1198                                     assert(ex == "+**********************0.");
   1199                                     assert(ios.width() == 0);
   1200                                 }
   1201                             }
   1202                             ios.imbue(lg);
   1203                             {
   1204                                 ios.width(0);
   1205                                 {
   1206                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1207                                     std::string ex(str, iter.base());
   1208                                     assert(ex == "+0;");
   1209                                     assert(ios.width() == 0);
   1210                                 }
   1211                                 ios.width(25);
   1212                                 left(ios);
   1213                                 {
   1214                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1215                                     std::string ex(str, iter.base());
   1216                                     assert(ex == "+0;**********************");
   1217                                     assert(ios.width() == 0);
   1218                                 }
   1219                                 ios.width(25);
   1220                                 right(ios);
   1221                                 {
   1222                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1223                                     std::string ex(str, iter.base());
   1224                                     assert(ex == "**********************+0;");
   1225                                     assert(ios.width() == 0);
   1226                                 }
   1227                                 ios.width(25);
   1228                                 internal(ios);
   1229                                 {
   1230                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1231                                     std::string ex(str, iter.base());
   1232                                     assert(ex == "+**********************0;");
   1233                                     assert(ios.width() == 0);
   1234                                 }
   1235                             }
   1236                         }
   1237                     }
   1238                 }
   1239             }
   1240             ios.precision(6);
   1241             {
   1242                 nouppercase(ios);
   1243                 {
   1244                     noshowpos(ios);
   1245                     {
   1246                         noshowpoint(ios);
   1247                         {
   1248                             ios.imbue(lc);
   1249                             {
   1250                                 ios.width(0);
   1251                                 {
   1252                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1253                                     std::string ex(str, iter.base());
   1254                                     assert(ex == "0");
   1255                                     assert(ios.width() == 0);
   1256                                 }
   1257                                 ios.width(25);
   1258                                 left(ios);
   1259                                 {
   1260                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1261                                     std::string ex(str, iter.base());
   1262                                     assert(ex == "0************************");
   1263                                     assert(ios.width() == 0);
   1264                                 }
   1265                                 ios.width(25);
   1266                                 right(ios);
   1267                                 {
   1268                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1269                                     std::string ex(str, iter.base());
   1270                                     assert(ex == "************************0");
   1271                                     assert(ios.width() == 0);
   1272                                 }
   1273                                 ios.width(25);
   1274                                 internal(ios);
   1275                                 {
   1276                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1277                                     std::string ex(str, iter.base());
   1278                                     assert(ex == "************************0");
   1279                                     assert(ios.width() == 0);
   1280                                 }
   1281                             }
   1282                             ios.imbue(lg);
   1283                             {
   1284                                 ios.width(0);
   1285                                 {
   1286                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1287                                     std::string ex(str, iter.base());
   1288                                     assert(ex == "0");
   1289                                     assert(ios.width() == 0);
   1290                                 }
   1291                                 ios.width(25);
   1292                                 left(ios);
   1293                                 {
   1294                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1295                                     std::string ex(str, iter.base());
   1296                                     assert(ex == "0************************");
   1297                                     assert(ios.width() == 0);
   1298                                 }
   1299                                 ios.width(25);
   1300                                 right(ios);
   1301                                 {
   1302                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1303                                     std::string ex(str, iter.base());
   1304                                     assert(ex == "************************0");
   1305                                     assert(ios.width() == 0);
   1306                                 }
   1307                                 ios.width(25);
   1308                                 internal(ios);
   1309                                 {
   1310                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1311                                     std::string ex(str, iter.base());
   1312                                     assert(ex == "************************0");
   1313                                     assert(ios.width() == 0);
   1314                                 }
   1315                             }
   1316                         }
   1317                         showpoint(ios);
   1318                         {
   1319                             ios.imbue(lc);
   1320                             {
   1321                                 ios.width(0);
   1322                                 {
   1323                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1324                                     std::string ex(str, iter.base());
   1325                                     assert(ex == "0.00000");
   1326                                     assert(ios.width() == 0);
   1327                                 }
   1328                                 ios.width(25);
   1329                                 left(ios);
   1330                                 {
   1331                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1332                                     std::string ex(str, iter.base());
   1333                                     assert(ex == "0.00000******************");
   1334                                     assert(ios.width() == 0);
   1335                                 }
   1336                                 ios.width(25);
   1337                                 right(ios);
   1338                                 {
   1339                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1340                                     std::string ex(str, iter.base());
   1341                                     assert(ex == "******************0.00000");
   1342                                     assert(ios.width() == 0);
   1343                                 }
   1344                                 ios.width(25);
   1345                                 internal(ios);
   1346                                 {
   1347                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1348                                     std::string ex(str, iter.base());
   1349                                     assert(ex == "******************0.00000");
   1350                                     assert(ios.width() == 0);
   1351                                 }
   1352                             }
   1353                             ios.imbue(lg);
   1354                             {
   1355                                 ios.width(0);
   1356                                 {
   1357                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1358                                     std::string ex(str, iter.base());
   1359                                     assert(ex == "0;00000");
   1360                                     assert(ios.width() == 0);
   1361                                 }
   1362                                 ios.width(25);
   1363                                 left(ios);
   1364                                 {
   1365                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1366                                     std::string ex(str, iter.base());
   1367                                     assert(ex == "0;00000******************");
   1368                                     assert(ios.width() == 0);
   1369                                 }
   1370                                 ios.width(25);
   1371                                 right(ios);
   1372                                 {
   1373                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1374                                     std::string ex(str, iter.base());
   1375                                     assert(ex == "******************0;00000");
   1376                                     assert(ios.width() == 0);
   1377                                 }
   1378                                 ios.width(25);
   1379                                 internal(ios);
   1380                                 {
   1381                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1382                                     std::string ex(str, iter.base());
   1383                                     assert(ex == "******************0;00000");
   1384                                     assert(ios.width() == 0);
   1385                                 }
   1386                             }
   1387                         }
   1388                     }
   1389                     showpos(ios);
   1390                     {
   1391                         noshowpoint(ios);
   1392                         {
   1393                             ios.imbue(lc);
   1394                             {
   1395                                 ios.width(0);
   1396                                 {
   1397                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1398                                     std::string ex(str, iter.base());
   1399                                     assert(ex == "+0");
   1400                                     assert(ios.width() == 0);
   1401                                 }
   1402                                 ios.width(25);
   1403                                 left(ios);
   1404                                 {
   1405                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1406                                     std::string ex(str, iter.base());
   1407                                     assert(ex == "+0***********************");
   1408                                     assert(ios.width() == 0);
   1409                                 }
   1410                                 ios.width(25);
   1411                                 right(ios);
   1412                                 {
   1413                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1414                                     std::string ex(str, iter.base());
   1415                                     assert(ex == "***********************+0");
   1416                                     assert(ios.width() == 0);
   1417                                 }
   1418                                 ios.width(25);
   1419                                 internal(ios);
   1420                                 {
   1421                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1422                                     std::string ex(str, iter.base());
   1423                                     assert(ex == "+***********************0");
   1424                                     assert(ios.width() == 0);
   1425                                 }
   1426                             }
   1427                             ios.imbue(lg);
   1428                             {
   1429                                 ios.width(0);
   1430                                 {
   1431                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1432                                     std::string ex(str, iter.base());
   1433                                     assert(ex == "+0");
   1434                                     assert(ios.width() == 0);
   1435                                 }
   1436                                 ios.width(25);
   1437                                 left(ios);
   1438                                 {
   1439                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1440                                     std::string ex(str, iter.base());
   1441                                     assert(ex == "+0***********************");
   1442                                     assert(ios.width() == 0);
   1443                                 }
   1444                                 ios.width(25);
   1445                                 right(ios);
   1446                                 {
   1447                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1448                                     std::string ex(str, iter.base());
   1449                                     assert(ex == "***********************+0");
   1450                                     assert(ios.width() == 0);
   1451                                 }
   1452                                 ios.width(25);
   1453                                 internal(ios);
   1454                                 {
   1455                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1456                                     std::string ex(str, iter.base());
   1457                                     assert(ex == "+***********************0");
   1458                                     assert(ios.width() == 0);
   1459                                 }
   1460                             }
   1461                         }
   1462                         showpoint(ios);
   1463                         {
   1464                             ios.imbue(lc);
   1465                             {
   1466                                 ios.width(0);
   1467                                 {
   1468                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1469                                     std::string ex(str, iter.base());
   1470                                     assert(ex == "+0.00000");
   1471                                     assert(ios.width() == 0);
   1472                                 }
   1473                                 ios.width(25);
   1474                                 left(ios);
   1475                                 {
   1476                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1477                                     std::string ex(str, iter.base());
   1478                                     assert(ex == "+0.00000*****************");
   1479                                     assert(ios.width() == 0);
   1480                                 }
   1481                                 ios.width(25);
   1482                                 right(ios);
   1483                                 {
   1484                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1485                                     std::string ex(str, iter.base());
   1486                                     assert(ex == "*****************+0.00000");
   1487                                     assert(ios.width() == 0);
   1488                                 }
   1489                                 ios.width(25);
   1490                                 internal(ios);
   1491                                 {
   1492                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1493                                     std::string ex(str, iter.base());
   1494                                     assert(ex == "+*****************0.00000");
   1495                                     assert(ios.width() == 0);
   1496                                 }
   1497                             }
   1498                             ios.imbue(lg);
   1499                             {
   1500                                 ios.width(0);
   1501                                 {
   1502                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1503                                     std::string ex(str, iter.base());
   1504                                     assert(ex == "+0;00000");
   1505                                     assert(ios.width() == 0);
   1506                                 }
   1507                                 ios.width(25);
   1508                                 left(ios);
   1509                                 {
   1510                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1511                                     std::string ex(str, iter.base());
   1512                                     assert(ex == "+0;00000*****************");
   1513                                     assert(ios.width() == 0);
   1514                                 }
   1515                                 ios.width(25);
   1516                                 right(ios);
   1517                                 {
   1518                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1519                                     std::string ex(str, iter.base());
   1520                                     assert(ex == "*****************+0;00000");
   1521                                     assert(ios.width() == 0);
   1522                                 }
   1523                                 ios.width(25);
   1524                                 internal(ios);
   1525                                 {
   1526                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1527                                     std::string ex(str, iter.base());
   1528                                     assert(ex == "+*****************0;00000");
   1529                                     assert(ios.width() == 0);
   1530                                 }
   1531                             }
   1532                         }
   1533                     }
   1534                 }
   1535                 uppercase(ios);
   1536                 {
   1537                     noshowpos(ios);
   1538                     {
   1539                         noshowpoint(ios);
   1540                         {
   1541                             ios.imbue(lc);
   1542                             {
   1543                                 ios.width(0);
   1544                                 {
   1545                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1546                                     std::string ex(str, iter.base());
   1547                                     assert(ex == "0");
   1548                                     assert(ios.width() == 0);
   1549                                 }
   1550                                 ios.width(25);
   1551                                 left(ios);
   1552                                 {
   1553                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1554                                     std::string ex(str, iter.base());
   1555                                     assert(ex == "0************************");
   1556                                     assert(ios.width() == 0);
   1557                                 }
   1558                                 ios.width(25);
   1559                                 right(ios);
   1560                                 {
   1561                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1562                                     std::string ex(str, iter.base());
   1563                                     assert(ex == "************************0");
   1564                                     assert(ios.width() == 0);
   1565                                 }
   1566                                 ios.width(25);
   1567                                 internal(ios);
   1568                                 {
   1569                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1570                                     std::string ex(str, iter.base());
   1571                                     assert(ex == "************************0");
   1572                                     assert(ios.width() == 0);
   1573                                 }
   1574                             }
   1575                             ios.imbue(lg);
   1576                             {
   1577                                 ios.width(0);
   1578                                 {
   1579                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1580                                     std::string ex(str, iter.base());
   1581                                     assert(ex == "0");
   1582                                     assert(ios.width() == 0);
   1583                                 }
   1584                                 ios.width(25);
   1585                                 left(ios);
   1586                                 {
   1587                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1588                                     std::string ex(str, iter.base());
   1589                                     assert(ex == "0************************");
   1590                                     assert(ios.width() == 0);
   1591                                 }
   1592                                 ios.width(25);
   1593                                 right(ios);
   1594                                 {
   1595                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1596                                     std::string ex(str, iter.base());
   1597                                     assert(ex == "************************0");
   1598                                     assert(ios.width() == 0);
   1599                                 }
   1600                                 ios.width(25);
   1601                                 internal(ios);
   1602                                 {
   1603                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1604                                     std::string ex(str, iter.base());
   1605                                     assert(ex == "************************0");
   1606                                     assert(ios.width() == 0);
   1607                                 }
   1608                             }
   1609                         }
   1610                         showpoint(ios);
   1611                         {
   1612                             ios.imbue(lc);
   1613                             {
   1614                                 ios.width(0);
   1615                                 {
   1616                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1617                                     std::string ex(str, iter.base());
   1618                                     assert(ex == "0.00000");
   1619                                     assert(ios.width() == 0);
   1620                                 }
   1621                                 ios.width(25);
   1622                                 left(ios);
   1623                                 {
   1624                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1625                                     std::string ex(str, iter.base());
   1626                                     assert(ex == "0.00000******************");
   1627                                     assert(ios.width() == 0);
   1628                                 }
   1629                                 ios.width(25);
   1630                                 right(ios);
   1631                                 {
   1632                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1633                                     std::string ex(str, iter.base());
   1634                                     assert(ex == "******************0.00000");
   1635                                     assert(ios.width() == 0);
   1636                                 }
   1637                                 ios.width(25);
   1638                                 internal(ios);
   1639                                 {
   1640                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1641                                     std::string ex(str, iter.base());
   1642                                     assert(ex == "******************0.00000");
   1643                                     assert(ios.width() == 0);
   1644                                 }
   1645                             }
   1646                             ios.imbue(lg);
   1647                             {
   1648                                 ios.width(0);
   1649                                 {
   1650                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1651                                     std::string ex(str, iter.base());
   1652                                     assert(ex == "0;00000");
   1653                                     assert(ios.width() == 0);
   1654                                 }
   1655                                 ios.width(25);
   1656                                 left(ios);
   1657                                 {
   1658                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1659                                     std::string ex(str, iter.base());
   1660                                     assert(ex == "0;00000******************");
   1661                                     assert(ios.width() == 0);
   1662                                 }
   1663                                 ios.width(25);
   1664                                 right(ios);
   1665                                 {
   1666                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1667                                     std::string ex(str, iter.base());
   1668                                     assert(ex == "******************0;00000");
   1669                                     assert(ios.width() == 0);
   1670                                 }
   1671                                 ios.width(25);
   1672                                 internal(ios);
   1673                                 {
   1674                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1675                                     std::string ex(str, iter.base());
   1676                                     assert(ex == "******************0;00000");
   1677                                     assert(ios.width() == 0);
   1678                                 }
   1679                             }
   1680                         }
   1681                     }
   1682                     showpos(ios);
   1683                     {
   1684                         noshowpoint(ios);
   1685                         {
   1686                             ios.imbue(lc);
   1687                             {
   1688                                 ios.width(0);
   1689                                 {
   1690                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1691                                     std::string ex(str, iter.base());
   1692                                     assert(ex == "+0");
   1693                                     assert(ios.width() == 0);
   1694                                 }
   1695                                 ios.width(25);
   1696                                 left(ios);
   1697                                 {
   1698                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1699                                     std::string ex(str, iter.base());
   1700                                     assert(ex == "+0***********************");
   1701                                     assert(ios.width() == 0);
   1702                                 }
   1703                                 ios.width(25);
   1704                                 right(ios);
   1705                                 {
   1706                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1707                                     std::string ex(str, iter.base());
   1708                                     assert(ex == "***********************+0");
   1709                                     assert(ios.width() == 0);
   1710                                 }
   1711                                 ios.width(25);
   1712                                 internal(ios);
   1713                                 {
   1714                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1715                                     std::string ex(str, iter.base());
   1716                                     assert(ex == "+***********************0");
   1717                                     assert(ios.width() == 0);
   1718                                 }
   1719                             }
   1720                             ios.imbue(lg);
   1721                             {
   1722                                 ios.width(0);
   1723                                 {
   1724                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1725                                     std::string ex(str, iter.base());
   1726                                     assert(ex == "+0");
   1727                                     assert(ios.width() == 0);
   1728                                 }
   1729                                 ios.width(25);
   1730                                 left(ios);
   1731                                 {
   1732                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1733                                     std::string ex(str, iter.base());
   1734                                     assert(ex == "+0***********************");
   1735                                     assert(ios.width() == 0);
   1736                                 }
   1737                                 ios.width(25);
   1738                                 right(ios);
   1739                                 {
   1740                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1741                                     std::string ex(str, iter.base());
   1742                                     assert(ex == "***********************+0");
   1743                                     assert(ios.width() == 0);
   1744                                 }
   1745                                 ios.width(25);
   1746                                 internal(ios);
   1747                                 {
   1748                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1749                                     std::string ex(str, iter.base());
   1750                                     assert(ex == "+***********************0");
   1751                                     assert(ios.width() == 0);
   1752                                 }
   1753                             }
   1754                         }
   1755                         showpoint(ios);
   1756                         {
   1757                             ios.imbue(lc);
   1758                             {
   1759                                 ios.width(0);
   1760                                 {
   1761                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1762                                     std::string ex(str, iter.base());
   1763                                     assert(ex == "+0.00000");
   1764                                     assert(ios.width() == 0);
   1765                                 }
   1766                                 ios.width(25);
   1767                                 left(ios);
   1768                                 {
   1769                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1770                                     std::string ex(str, iter.base());
   1771                                     assert(ex == "+0.00000*****************");
   1772                                     assert(ios.width() == 0);
   1773                                 }
   1774                                 ios.width(25);
   1775                                 right(ios);
   1776                                 {
   1777                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1778                                     std::string ex(str, iter.base());
   1779                                     assert(ex == "*****************+0.00000");
   1780                                     assert(ios.width() == 0);
   1781                                 }
   1782                                 ios.width(25);
   1783                                 internal(ios);
   1784                                 {
   1785                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1786                                     std::string ex(str, iter.base());
   1787                                     assert(ex == "+*****************0.00000");
   1788                                     assert(ios.width() == 0);
   1789                                 }
   1790                             }
   1791                             ios.imbue(lg);
   1792                             {
   1793                                 ios.width(0);
   1794                                 {
   1795                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1796                                     std::string ex(str, iter.base());
   1797                                     assert(ex == "+0;00000");
   1798                                     assert(ios.width() == 0);
   1799                                 }
   1800                                 ios.width(25);
   1801                                 left(ios);
   1802                                 {
   1803                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1804                                     std::string ex(str, iter.base());
   1805                                     assert(ex == "+0;00000*****************");
   1806                                     assert(ios.width() == 0);
   1807                                 }
   1808                                 ios.width(25);
   1809                                 right(ios);
   1810                                 {
   1811                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1812                                     std::string ex(str, iter.base());
   1813                                     assert(ex == "*****************+0;00000");
   1814                                     assert(ios.width() == 0);
   1815                                 }
   1816                                 ios.width(25);
   1817                                 internal(ios);
   1818                                 {
   1819                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1820                                     std::string ex(str, iter.base());
   1821                                     assert(ex == "+*****************0;00000");
   1822                                     assert(ios.width() == 0);
   1823                                 }
   1824                             }
   1825                         }
   1826                     }
   1827                 }
   1828             }
   1829             ios.precision(16);
   1830             {
   1831                 nouppercase(ios);
   1832                 {
   1833                     noshowpos(ios);
   1834                     {
   1835                         noshowpoint(ios);
   1836                         {
   1837                             ios.imbue(lc);
   1838                             {
   1839                                 ios.width(0);
   1840                                 {
   1841                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1842                                     std::string ex(str, iter.base());
   1843                                     assert(ex == "0");
   1844                                     assert(ios.width() == 0);
   1845                                 }
   1846                                 ios.width(25);
   1847                                 left(ios);
   1848                                 {
   1849                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1850                                     std::string ex(str, iter.base());
   1851                                     assert(ex == "0************************");
   1852                                     assert(ios.width() == 0);
   1853                                 }
   1854                                 ios.width(25);
   1855                                 right(ios);
   1856                                 {
   1857                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1858                                     std::string ex(str, iter.base());
   1859                                     assert(ex == "************************0");
   1860                                     assert(ios.width() == 0);
   1861                                 }
   1862                                 ios.width(25);
   1863                                 internal(ios);
   1864                                 {
   1865                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1866                                     std::string ex(str, iter.base());
   1867                                     assert(ex == "************************0");
   1868                                     assert(ios.width() == 0);
   1869                                 }
   1870                             }
   1871                             ios.imbue(lg);
   1872                             {
   1873                                 ios.width(0);
   1874                                 {
   1875                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1876                                     std::string ex(str, iter.base());
   1877                                     assert(ex == "0");
   1878                                     assert(ios.width() == 0);
   1879                                 }
   1880                                 ios.width(25);
   1881                                 left(ios);
   1882                                 {
   1883                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1884                                     std::string ex(str, iter.base());
   1885                                     assert(ex == "0************************");
   1886                                     assert(ios.width() == 0);
   1887                                 }
   1888                                 ios.width(25);
   1889                                 right(ios);
   1890                                 {
   1891                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1892                                     std::string ex(str, iter.base());
   1893                                     assert(ex == "************************0");
   1894                                     assert(ios.width() == 0);
   1895                                 }
   1896                                 ios.width(25);
   1897                                 internal(ios);
   1898                                 {
   1899                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1900                                     std::string ex(str, iter.base());
   1901                                     assert(ex == "************************0");
   1902                                     assert(ios.width() == 0);
   1903                                 }
   1904                             }
   1905                         }
   1906                         showpoint(ios);
   1907                         {
   1908                             ios.imbue(lc);
   1909                             {
   1910                                 ios.width(0);
   1911                                 {
   1912                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1913                                     std::string ex(str, iter.base());
   1914                                     assert(ex == "0.000000000000000");
   1915                                     assert(ios.width() == 0);
   1916                                 }
   1917                                 ios.width(25);
   1918                                 left(ios);
   1919                                 {
   1920                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1921                                     std::string ex(str, iter.base());
   1922                                     assert(ex == "0.000000000000000********");
   1923                                     assert(ios.width() == 0);
   1924                                 }
   1925                                 ios.width(25);
   1926                                 right(ios);
   1927                                 {
   1928                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1929                                     std::string ex(str, iter.base());
   1930                                     assert(ex == "********0.000000000000000");
   1931                                     assert(ios.width() == 0);
   1932                                 }
   1933                                 ios.width(25);
   1934                                 internal(ios);
   1935                                 {
   1936                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1937                                     std::string ex(str, iter.base());
   1938                                     assert(ex == "********0.000000000000000");
   1939                                     assert(ios.width() == 0);
   1940                                 }
   1941                             }
   1942                             ios.imbue(lg);
   1943                             {
   1944                                 ios.width(0);
   1945                                 {
   1946                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1947                                     std::string ex(str, iter.base());
   1948                                     assert(ex == "0;000000000000000");
   1949                                     assert(ios.width() == 0);
   1950                                 }
   1951                                 ios.width(25);
   1952                                 left(ios);
   1953                                 {
   1954                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1955                                     std::string ex(str, iter.base());
   1956                                     assert(ex == "0;000000000000000********");
   1957                                     assert(ios.width() == 0);
   1958                                 }
   1959                                 ios.width(25);
   1960                                 right(ios);
   1961                                 {
   1962                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1963                                     std::string ex(str, iter.base());
   1964                                     assert(ex == "********0;000000000000000");
   1965                                     assert(ios.width() == 0);
   1966                                 }
   1967                                 ios.width(25);
   1968                                 internal(ios);
   1969                                 {
   1970                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1971                                     std::string ex(str, iter.base());
   1972                                     assert(ex == "********0;000000000000000");
   1973                                     assert(ios.width() == 0);
   1974                                 }
   1975                             }
   1976                         }
   1977                     }
   1978                     showpos(ios);
   1979                     {
   1980                         noshowpoint(ios);
   1981                         {
   1982                             ios.imbue(lc);
   1983                             {
   1984                                 ios.width(0);
   1985                                 {
   1986                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1987                                     std::string ex(str, iter.base());
   1988                                     assert(ex == "+0");
   1989                                     assert(ios.width() == 0);
   1990                                 }
   1991                                 ios.width(25);
   1992                                 left(ios);
   1993                                 {
   1994                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1995                                     std::string ex(str, iter.base());
   1996                                     assert(ex == "+0***********************");
   1997                                     assert(ios.width() == 0);
   1998                                 }
   1999                                 ios.width(25);
   2000                                 right(ios);
   2001                                 {
   2002                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2003                                     std::string ex(str, iter.base());
   2004                                     assert(ex == "***********************+0");
   2005                                     assert(ios.width() == 0);
   2006                                 }
   2007                                 ios.width(25);
   2008                                 internal(ios);
   2009                                 {
   2010                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2011                                     std::string ex(str, iter.base());
   2012                                     assert(ex == "+***********************0");
   2013                                     assert(ios.width() == 0);
   2014                                 }
   2015                             }
   2016                             ios.imbue(lg);
   2017                             {
   2018                                 ios.width(0);
   2019                                 {
   2020                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2021                                     std::string ex(str, iter.base());
   2022                                     assert(ex == "+0");
   2023                                     assert(ios.width() == 0);
   2024                                 }
   2025                                 ios.width(25);
   2026                                 left(ios);
   2027                                 {
   2028                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2029                                     std::string ex(str, iter.base());
   2030                                     assert(ex == "+0***********************");
   2031                                     assert(ios.width() == 0);
   2032                                 }
   2033                                 ios.width(25);
   2034                                 right(ios);
   2035                                 {
   2036                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2037                                     std::string ex(str, iter.base());
   2038                                     assert(ex == "***********************+0");
   2039                                     assert(ios.width() == 0);
   2040                                 }
   2041                                 ios.width(25);
   2042                                 internal(ios);
   2043                                 {
   2044                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2045                                     std::string ex(str, iter.base());
   2046                                     assert(ex == "+***********************0");
   2047                                     assert(ios.width() == 0);
   2048                                 }
   2049                             }
   2050                         }
   2051                         showpoint(ios);
   2052                         {
   2053                             ios.imbue(lc);
   2054                             {
   2055                                 ios.width(0);
   2056                                 {
   2057                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2058                                     std::string ex(str, iter.base());
   2059                                     assert(ex == "+0.000000000000000");
   2060                                     assert(ios.width() == 0);
   2061                                 }
   2062                                 ios.width(25);
   2063                                 left(ios);
   2064                                 {
   2065                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2066                                     std::string ex(str, iter.base());
   2067                                     assert(ex == "+0.000000000000000*******");
   2068                                     assert(ios.width() == 0);
   2069                                 }
   2070                                 ios.width(25);
   2071                                 right(ios);
   2072                                 {
   2073                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2074                                     std::string ex(str, iter.base());
   2075                                     assert(ex == "*******+0.000000000000000");
   2076                                     assert(ios.width() == 0);
   2077                                 }
   2078                                 ios.width(25);
   2079                                 internal(ios);
   2080                                 {
   2081                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2082                                     std::string ex(str, iter.base());
   2083                                     assert(ex == "+*******0.000000000000000");
   2084                                     assert(ios.width() == 0);
   2085                                 }
   2086                             }
   2087                             ios.imbue(lg);
   2088                             {
   2089                                 ios.width(0);
   2090                                 {
   2091                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2092                                     std::string ex(str, iter.base());
   2093                                     assert(ex == "+0;000000000000000");
   2094                                     assert(ios.width() == 0);
   2095                                 }
   2096                                 ios.width(25);
   2097                                 left(ios);
   2098                                 {
   2099                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2100                                     std::string ex(str, iter.base());
   2101                                     assert(ex == "+0;000000000000000*******");
   2102                                     assert(ios.width() == 0);
   2103                                 }
   2104                                 ios.width(25);
   2105                                 right(ios);
   2106                                 {
   2107                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2108                                     std::string ex(str, iter.base());
   2109                                     assert(ex == "*******+0;000000000000000");
   2110                                     assert(ios.width() == 0);
   2111                                 }
   2112                                 ios.width(25);
   2113                                 internal(ios);
   2114                                 {
   2115                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2116                                     std::string ex(str, iter.base());
   2117                                     assert(ex == "+*******0;000000000000000");
   2118                                     assert(ios.width() == 0);
   2119                                 }
   2120                             }
   2121                         }
   2122                     }
   2123                 }
   2124                 uppercase(ios);
   2125                 {
   2126                     noshowpos(ios);
   2127                     {
   2128                         noshowpoint(ios);
   2129                         {
   2130                             ios.imbue(lc);
   2131                             {
   2132                                 ios.width(0);
   2133                                 {
   2134                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2135                                     std::string ex(str, iter.base());
   2136                                     assert(ex == "0");
   2137                                     assert(ios.width() == 0);
   2138                                 }
   2139                                 ios.width(25);
   2140                                 left(ios);
   2141                                 {
   2142                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2143                                     std::string ex(str, iter.base());
   2144                                     assert(ex == "0************************");
   2145                                     assert(ios.width() == 0);
   2146                                 }
   2147                                 ios.width(25);
   2148                                 right(ios);
   2149                                 {
   2150                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2151                                     std::string ex(str, iter.base());
   2152                                     assert(ex == "************************0");
   2153                                     assert(ios.width() == 0);
   2154                                 }
   2155                                 ios.width(25);
   2156                                 internal(ios);
   2157                                 {
   2158                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2159                                     std::string ex(str, iter.base());
   2160                                     assert(ex == "************************0");
   2161                                     assert(ios.width() == 0);
   2162                                 }
   2163                             }
   2164                             ios.imbue(lg);
   2165                             {
   2166                                 ios.width(0);
   2167                                 {
   2168                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2169                                     std::string ex(str, iter.base());
   2170                                     assert(ex == "0");
   2171                                     assert(ios.width() == 0);
   2172                                 }
   2173                                 ios.width(25);
   2174                                 left(ios);
   2175                                 {
   2176                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2177                                     std::string ex(str, iter.base());
   2178                                     assert(ex == "0************************");
   2179                                     assert(ios.width() == 0);
   2180                                 }
   2181                                 ios.width(25);
   2182                                 right(ios);
   2183                                 {
   2184                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2185                                     std::string ex(str, iter.base());
   2186                                     assert(ex == "************************0");
   2187                                     assert(ios.width() == 0);
   2188                                 }
   2189                                 ios.width(25);
   2190                                 internal(ios);
   2191                                 {
   2192                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2193                                     std::string ex(str, iter.base());
   2194                                     assert(ex == "************************0");
   2195                                     assert(ios.width() == 0);
   2196                                 }
   2197                             }
   2198                         }
   2199                         showpoint(ios);
   2200                         {
   2201                             ios.imbue(lc);
   2202                             {
   2203                                 ios.width(0);
   2204                                 {
   2205                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2206                                     std::string ex(str, iter.base());
   2207                                     assert(ex == "0.000000000000000");
   2208                                     assert(ios.width() == 0);
   2209                                 }
   2210                                 ios.width(25);
   2211                                 left(ios);
   2212                                 {
   2213                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2214                                     std::string ex(str, iter.base());
   2215                                     assert(ex == "0.000000000000000********");
   2216                                     assert(ios.width() == 0);
   2217                                 }
   2218                                 ios.width(25);
   2219                                 right(ios);
   2220                                 {
   2221                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2222                                     std::string ex(str, iter.base());
   2223                                     assert(ex == "********0.000000000000000");
   2224                                     assert(ios.width() == 0);
   2225                                 }
   2226                                 ios.width(25);
   2227                                 internal(ios);
   2228                                 {
   2229                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2230                                     std::string ex(str, iter.base());
   2231                                     assert(ex == "********0.000000000000000");
   2232                                     assert(ios.width() == 0);
   2233                                 }
   2234                             }
   2235                             ios.imbue(lg);
   2236                             {
   2237                                 ios.width(0);
   2238                                 {
   2239                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2240                                     std::string ex(str, iter.base());
   2241                                     assert(ex == "0;000000000000000");
   2242                                     assert(ios.width() == 0);
   2243                                 }
   2244                                 ios.width(25);
   2245                                 left(ios);
   2246                                 {
   2247                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2248                                     std::string ex(str, iter.base());
   2249                                     assert(ex == "0;000000000000000********");
   2250                                     assert(ios.width() == 0);
   2251                                 }
   2252                                 ios.width(25);
   2253                                 right(ios);
   2254                                 {
   2255                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2256                                     std::string ex(str, iter.base());
   2257                                     assert(ex == "********0;000000000000000");
   2258                                     assert(ios.width() == 0);
   2259                                 }
   2260                                 ios.width(25);
   2261                                 internal(ios);
   2262                                 {
   2263                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2264                                     std::string ex(str, iter.base());
   2265                                     assert(ex == "********0;000000000000000");
   2266                                     assert(ios.width() == 0);
   2267                                 }
   2268                             }
   2269                         }
   2270                     }
   2271                     showpos(ios);
   2272                     {
   2273                         noshowpoint(ios);
   2274                         {
   2275                             ios.imbue(lc);
   2276                             {
   2277                                 ios.width(0);
   2278                                 {
   2279                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2280                                     std::string ex(str, iter.base());
   2281                                     assert(ex == "+0");
   2282                                     assert(ios.width() == 0);
   2283                                 }
   2284                                 ios.width(25);
   2285                                 left(ios);
   2286                                 {
   2287                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2288                                     std::string ex(str, iter.base());
   2289                                     assert(ex == "+0***********************");
   2290                                     assert(ios.width() == 0);
   2291                                 }
   2292                                 ios.width(25);
   2293                                 right(ios);
   2294                                 {
   2295                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2296                                     std::string ex(str, iter.base());
   2297                                     assert(ex == "***********************+0");
   2298                                     assert(ios.width() == 0);
   2299                                 }
   2300                                 ios.width(25);
   2301                                 internal(ios);
   2302                                 {
   2303                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2304                                     std::string ex(str, iter.base());
   2305                                     assert(ex == "+***********************0");
   2306                                     assert(ios.width() == 0);
   2307                                 }
   2308                             }
   2309                             ios.imbue(lg);
   2310                             {
   2311                                 ios.width(0);
   2312                                 {
   2313                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2314                                     std::string ex(str, iter.base());
   2315                                     assert(ex == "+0");
   2316                                     assert(ios.width() == 0);
   2317                                 }
   2318                                 ios.width(25);
   2319                                 left(ios);
   2320                                 {
   2321                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2322                                     std::string ex(str, iter.base());
   2323                                     assert(ex == "+0***********************");
   2324                                     assert(ios.width() == 0);
   2325                                 }
   2326                                 ios.width(25);
   2327                                 right(ios);
   2328                                 {
   2329                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2330                                     std::string ex(str, iter.base());
   2331                                     assert(ex == "***********************+0");
   2332                                     assert(ios.width() == 0);
   2333                                 }
   2334                                 ios.width(25);
   2335                                 internal(ios);
   2336                                 {
   2337                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2338                                     std::string ex(str, iter.base());
   2339                                     assert(ex == "+***********************0");
   2340                                     assert(ios.width() == 0);
   2341                                 }
   2342                             }
   2343                         }
   2344                         showpoint(ios);
   2345                         {
   2346                             ios.imbue(lc);
   2347                             {
   2348                                 ios.width(0);
   2349                                 {
   2350                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2351                                     std::string ex(str, iter.base());
   2352                                     assert(ex == "+0.000000000000000");
   2353                                     assert(ios.width() == 0);
   2354                                 }
   2355                                 ios.width(25);
   2356                                 left(ios);
   2357                                 {
   2358                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2359                                     std::string ex(str, iter.base());
   2360                                     assert(ex == "+0.000000000000000*******");
   2361                                     assert(ios.width() == 0);
   2362                                 }
   2363                                 ios.width(25);
   2364                                 right(ios);
   2365                                 {
   2366                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2367                                     std::string ex(str, iter.base());
   2368                                     assert(ex == "*******+0.000000000000000");
   2369                                     assert(ios.width() == 0);
   2370                                 }
   2371                                 ios.width(25);
   2372                                 internal(ios);
   2373                                 {
   2374                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2375                                     std::string ex(str, iter.base());
   2376                                     assert(ex == "+*******0.000000000000000");
   2377                                     assert(ios.width() == 0);
   2378                                 }
   2379                             }
   2380                             ios.imbue(lg);
   2381                             {
   2382                                 ios.width(0);
   2383                                 {
   2384                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2385                                     std::string ex(str, iter.base());
   2386                                     assert(ex == "+0;000000000000000");
   2387                                     assert(ios.width() == 0);
   2388                                 }
   2389                                 ios.width(25);
   2390                                 left(ios);
   2391                                 {
   2392                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2393                                     std::string ex(str, iter.base());
   2394                                     assert(ex == "+0;000000000000000*******");
   2395                                     assert(ios.width() == 0);
   2396                                 }
   2397                                 ios.width(25);
   2398                                 right(ios);
   2399                                 {
   2400                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2401                                     std::string ex(str, iter.base());
   2402                                     assert(ex == "*******+0;000000000000000");
   2403                                     assert(ios.width() == 0);
   2404                                 }
   2405                                 ios.width(25);
   2406                                 internal(ios);
   2407                                 {
   2408                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2409                                     std::string ex(str, iter.base());
   2410                                     assert(ex == "+*******0;000000000000000");
   2411                                     assert(ios.width() == 0);
   2412                                 }
   2413                             }
   2414                         }
   2415                     }
   2416                 }
   2417             }
   2418             ios.precision(60);
   2419             {
   2420                 nouppercase(ios);
   2421                 {
   2422                     noshowpos(ios);
   2423                     {
   2424                         noshowpoint(ios);
   2425                         {
   2426                             ios.imbue(lc);
   2427                             {
   2428                                 ios.width(0);
   2429                                 {
   2430                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2431                                     std::string ex(str, iter.base());
   2432                                     assert(ex == "0");
   2433                                     assert(ios.width() == 0);
   2434                                 }
   2435                                 ios.width(25);
   2436                                 left(ios);
   2437                                 {
   2438                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2439                                     std::string ex(str, iter.base());
   2440                                     assert(ex == "0************************");
   2441                                     assert(ios.width() == 0);
   2442                                 }
   2443                                 ios.width(25);
   2444                                 right(ios);
   2445                                 {
   2446                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2447                                     std::string ex(str, iter.base());
   2448                                     assert(ex == "************************0");
   2449                                     assert(ios.width() == 0);
   2450                                 }
   2451                                 ios.width(25);
   2452                                 internal(ios);
   2453                                 {
   2454                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2455                                     std::string ex(str, iter.base());
   2456                                     assert(ex == "************************0");
   2457                                     assert(ios.width() == 0);
   2458                                 }
   2459                             }
   2460                             ios.imbue(lg);
   2461                             {
   2462                                 ios.width(0);
   2463                                 {
   2464                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2465                                     std::string ex(str, iter.base());
   2466                                     assert(ex == "0");
   2467                                     assert(ios.width() == 0);
   2468                                 }
   2469                                 ios.width(25);
   2470                                 left(ios);
   2471                                 {
   2472                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2473                                     std::string ex(str, iter.base());
   2474                                     assert(ex == "0************************");
   2475                                     assert(ios.width() == 0);
   2476                                 }
   2477                                 ios.width(25);
   2478                                 right(ios);
   2479                                 {
   2480                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2481                                     std::string ex(str, iter.base());
   2482                                     assert(ex == "************************0");
   2483                                     assert(ios.width() == 0);
   2484                                 }
   2485                                 ios.width(25);
   2486                                 internal(ios);
   2487                                 {
   2488                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2489                                     std::string ex(str, iter.base());
   2490                                     assert(ex == "************************0");
   2491                                     assert(ios.width() == 0);
   2492                                 }
   2493                             }
   2494                         }
   2495                         showpoint(ios);
   2496                         {
   2497                             ios.imbue(lc);
   2498                             {
   2499                                 ios.width(0);
   2500                                 {
   2501                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2502                                     std::string ex(str, iter.base());
   2503                                     assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
   2504                                     assert(ios.width() == 0);
   2505                                 }
   2506                                 ios.width(25);
   2507                                 left(ios);
   2508                                 {
   2509                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2510                                     std::string ex(str, iter.base());
   2511                                     assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
   2512                                     assert(ios.width() == 0);
   2513                                 }
   2514                                 ios.width(25);
   2515                                 right(ios);
   2516                                 {
   2517                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2518                                     std::string ex(str, iter.base());
   2519                                     assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
   2520                                     assert(ios.width() == 0);
   2521                                 }
   2522                                 ios.width(25);
   2523                                 internal(ios);
   2524                                 {
   2525                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2526                                     std::string ex(str, iter.base());
   2527                                     assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
   2528                                     assert(ios.width() == 0);
   2529                                 }
   2530                             }
   2531                             ios.imbue(lg);
   2532                             {
   2533                                 ios.width(0);
   2534                                 {
   2535                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2536                                     std::string ex(str, iter.base());
   2537                                     assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
   2538                                     assert(ios.width() == 0);
   2539                                 }
   2540                                 ios.width(25);
   2541                                 left(ios);
   2542                                 {
   2543                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2544                                     std::string ex(str, iter.base());
   2545                                     assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
   2546                                     assert(ios.width() == 0);
   2547                                 }
   2548                                 ios.width(25);
   2549                                 right(ios);
   2550                                 {
   2551                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2552                                     std::string ex(str, iter.base());
   2553                                     assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
   2554                                     assert(ios.width() == 0);
   2555                                 }
   2556                                 ios.width(25);
   2557                                 internal(ios);
   2558                                 {
   2559                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2560                                     std::string ex(str, iter.base());
   2561                                     assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
   2562                                     assert(ios.width() == 0);
   2563                                 }
   2564                             }
   2565                         }
   2566                     }
   2567                     showpos(ios);
   2568                     {
   2569                         noshowpoint(ios);
   2570                         {
   2571                             ios.imbue(lc);
   2572                             {
   2573                                 ios.width(0);
   2574                                 {
   2575                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2576                                     std::string ex(str, iter.base());
   2577                                     assert(ex == "+0");
   2578                                     assert(ios.width() == 0);
   2579                                 }
   2580                                 ios.width(25);
   2581                                 left(ios);
   2582                                 {
   2583                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2584                                     std::string ex(str, iter.base());
   2585                                     assert(ex == "+0***********************");
   2586                                     assert(ios.width() == 0);
   2587                                 }
   2588                                 ios.width(25);
   2589                                 right(ios);
   2590                                 {
   2591                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2592                                     std::string ex(str, iter.base());
   2593                                     assert(ex == "***********************+0");
   2594                                     assert(ios.width() == 0);
   2595                                 }
   2596                                 ios.width(25);
   2597                                 internal(ios);
   2598                                 {
   2599                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2600                                     std::string ex(str, iter.base());
   2601                                     assert(ex == "+***********************0");
   2602                                     assert(ios.width() == 0);
   2603                                 }
   2604                             }
   2605                             ios.imbue(lg);
   2606                             {
   2607                                 ios.width(0);
   2608                                 {
   2609                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2610                                     std::string ex(str, iter.base());
   2611                                     assert(ex == "+0");
   2612                                     assert(ios.width() == 0);
   2613                                 }
   2614                                 ios.width(25);
   2615                                 left(ios);
   2616                                 {
   2617                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2618                                     std::string ex(str, iter.base());
   2619                                     assert(ex == "+0***********************");
   2620                                     assert(ios.width() == 0);
   2621                                 }
   2622                                 ios.width(25);
   2623                                 right(ios);
   2624                                 {
   2625                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2626                                     std::string ex(str, iter.base());
   2627                                     assert(ex == "***********************+0");
   2628                                     assert(ios.width() == 0);
   2629                                 }
   2630                                 ios.width(25);
   2631                                 internal(ios);
   2632                                 {
   2633                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2634                                     std::string ex(str, iter.base());
   2635                                     assert(ex == "+***********************0");
   2636                                     assert(ios.width() == 0);
   2637                                 }
   2638                             }
   2639                         }
   2640                         showpoint(ios);
   2641                         {
   2642                             ios.imbue(lc);
   2643                             {
   2644                                 ios.width(0);
   2645                                 {
   2646                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2647                                     std::string ex(str, iter.base());
   2648                                     assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
   2649                                     assert(ios.width() == 0);
   2650                                 }
   2651                                 ios.width(25);
   2652                                 left(ios);
   2653                                 {
   2654                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2655                                     std::string ex(str, iter.base());
   2656                                     assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
   2657                                     assert(ios.width() == 0);
   2658                                 }
   2659                                 ios.width(25);
   2660                                 right(ios);
   2661                                 {
   2662                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2663                                     std::string ex(str, iter.base());
   2664                                     assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
   2665                                     assert(ios.width() == 0);
   2666                                 }
   2667                                 ios.width(25);
   2668                                 internal(ios);
   2669                                 {
   2670                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2671                                     std::string ex(str, iter.base());
   2672                                     assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
   2673                                     assert(ios.width() == 0);
   2674                                 }
   2675                             }
   2676                             ios.imbue(lg);
   2677                             {
   2678                                 ios.width(0);
   2679                                 {
   2680                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2681                                     std::string ex(str, iter.base());
   2682                                     assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
   2683                                     assert(ios.width() == 0);
   2684                                 }
   2685                                 ios.width(25);
   2686                                 left(ios);
   2687                                 {
   2688                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2689                                     std::string ex(str, iter.base());
   2690                                     assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
   2691                                     assert(ios.width() == 0);
   2692                                 }
   2693                                 ios.width(25);
   2694                                 right(ios);
   2695                                 {
   2696                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2697                                     std::string ex(str, iter.base());
   2698                                     assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
   2699                                     assert(ios.width() == 0);
   2700                                 }
   2701                                 ios.width(25);
   2702                                 internal(ios);
   2703                                 {
   2704                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2705                                     std::string ex(str, iter.base());
   2706                                     assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
   2707                                     assert(ios.width() == 0);
   2708                                 }
   2709                             }
   2710                         }
   2711                     }
   2712                 }
   2713                 uppercase(ios);
   2714                 {
   2715                     noshowpos(ios);
   2716                     {
   2717                         noshowpoint(ios);
   2718                         {
   2719                             ios.imbue(lc);
   2720                             {
   2721                                 ios.width(0);
   2722                                 {
   2723                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2724                                     std::string ex(str, iter.base());
   2725                                     assert(ex == "0");
   2726                                     assert(ios.width() == 0);
   2727                                 }
   2728                                 ios.width(25);
   2729                                 left(ios);
   2730                                 {
   2731                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2732                                     std::string ex(str, iter.base());
   2733                                     assert(ex == "0************************");
   2734                                     assert(ios.width() == 0);
   2735                                 }
   2736                                 ios.width(25);
   2737                                 right(ios);
   2738                                 {
   2739                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2740                                     std::string ex(str, iter.base());
   2741                                     assert(ex == "************************0");
   2742                                     assert(ios.width() == 0);
   2743                                 }
   2744                                 ios.width(25);
   2745                                 internal(ios);
   2746                                 {
   2747                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2748                                     std::string ex(str, iter.base());
   2749                                     assert(ex == "************************0");
   2750                                     assert(ios.width() == 0);
   2751                                 }
   2752                             }
   2753                             ios.imbue(lg);
   2754                             {
   2755                                 ios.width(0);
   2756                                 {
   2757                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2758                                     std::string ex(str, iter.base());
   2759                                     assert(ex == "0");
   2760                                     assert(ios.width() == 0);
   2761                                 }
   2762                                 ios.width(25);
   2763                                 left(ios);
   2764                                 {
   2765                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2766                                     std::string ex(str, iter.base());
   2767                                     assert(ex == "0************************");
   2768                                     assert(ios.width() == 0);
   2769                                 }
   2770                                 ios.width(25);
   2771                                 right(ios);
   2772                                 {
   2773                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2774                                     std::string ex(str, iter.base());
   2775                                     assert(ex == "************************0");
   2776                                     assert(ios.width() == 0);
   2777                                 }
   2778                                 ios.width(25);
   2779                                 internal(ios);
   2780                                 {
   2781                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2782                                     std::string ex(str, iter.base());
   2783                                     assert(ex == "************************0");
   2784                                     assert(ios.width() == 0);
   2785                                 }
   2786                             }
   2787                         }
   2788                         showpoint(ios);
   2789                         {
   2790                             ios.imbue(lc);
   2791                             {
   2792                                 ios.width(0);
   2793                                 {
   2794                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2795                                     std::string ex(str, iter.base());
   2796                                     assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
   2797                                     assert(ios.width() == 0);
   2798                                 }
   2799                                 ios.width(25);
   2800                                 left(ios);
   2801                                 {
   2802                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2803                                     std::string ex(str, iter.base());
   2804                                     assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
   2805                                     assert(ios.width() == 0);
   2806                                 }
   2807                                 ios.width(25);
   2808                                 right(ios);
   2809                                 {
   2810                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2811                                     std::string ex(str, iter.base());
   2812                                     assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
   2813                                     assert(ios.width() == 0);
   2814                                 }
   2815                                 ios.width(25);
   2816                                 internal(ios);
   2817                                 {
   2818                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2819                                     std::string ex(str, iter.base());
   2820                                     assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
   2821                                     assert(ios.width() == 0);
   2822                                 }
   2823                             }
   2824                             ios.imbue(lg);
   2825                             {
   2826                                 ios.width(0);
   2827                                 {
   2828                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2829                                     std::string ex(str, iter.base());
   2830                                     assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
   2831                                     assert(ios.width() == 0);
   2832                                 }
   2833                                 ios.width(25);
   2834                                 left(ios);
   2835                                 {
   2836                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2837                                     std::string ex(str, iter.base());
   2838                                     assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
   2839                                     assert(ios.width() == 0);
   2840                                 }
   2841                                 ios.width(25);
   2842                                 right(ios);
   2843                                 {
   2844                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2845                                     std::string ex(str, iter.base());
   2846                                     assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
   2847                                     assert(ios.width() == 0);
   2848                                 }
   2849                                 ios.width(25);
   2850                                 internal(ios);
   2851                                 {
   2852                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2853                                     std::string ex(str, iter.base());
   2854                                     assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
   2855                                     assert(ios.width() == 0);
   2856                                 }
   2857                             }
   2858                         }
   2859                     }
   2860                     showpos(ios);
   2861                     {
   2862                         noshowpoint(ios);
   2863                         {
   2864                             ios.imbue(lc);
   2865                             {
   2866                                 ios.width(0);
   2867                                 {
   2868                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2869                                     std::string ex(str, iter.base());
   2870                                     assert(ex == "+0");
   2871                                     assert(ios.width() == 0);
   2872                                 }
   2873                                 ios.width(25);
   2874                                 left(ios);
   2875                                 {
   2876                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2877                                     std::string ex(str, iter.base());
   2878                                     assert(ex == "+0***********************");
   2879                                     assert(ios.width() == 0);
   2880                                 }
   2881                                 ios.width(25);
   2882                                 right(ios);
   2883                                 {
   2884                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2885                                     std::string ex(str, iter.base());
   2886                                     assert(ex == "***********************+0");
   2887                                     assert(ios.width() == 0);
   2888                                 }
   2889                                 ios.width(25);
   2890                                 internal(ios);
   2891                                 {
   2892                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2893                                     std::string ex(str, iter.base());
   2894                                     assert(ex == "+***********************0");
   2895                                     assert(ios.width() == 0);
   2896                                 }
   2897                             }
   2898                             ios.imbue(lg);
   2899                             {
   2900                                 ios.width(0);
   2901                                 {
   2902                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2903                                     std::string ex(str, iter.base());
   2904                                     assert(ex == "+0");
   2905                                     assert(ios.width() == 0);
   2906                                 }
   2907                                 ios.width(25);
   2908                                 left(ios);
   2909                                 {
   2910                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2911                                     std::string ex(str, iter.base());
   2912                                     assert(ex == "+0***********************");
   2913                                     assert(ios.width() == 0);
   2914                                 }
   2915                                 ios.width(25);
   2916                                 right(ios);
   2917                                 {
   2918                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2919                                     std::string ex(str, iter.base());
   2920                                     assert(ex == "***********************+0");
   2921                                     assert(ios.width() == 0);
   2922                                 }
   2923                                 ios.width(25);
   2924                                 internal(ios);
   2925                                 {
   2926                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2927                                     std::string ex(str, iter.base());
   2928                                     assert(ex == "+***********************0");
   2929                                     assert(ios.width() == 0);
   2930                                 }
   2931                             }
   2932                         }
   2933                         showpoint(ios);
   2934                         {
   2935                             ios.imbue(lc);
   2936                             {
   2937                                 ios.width(0);
   2938                                 {
   2939                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2940                                     std::string ex(str, iter.base());
   2941                                     assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
   2942                                     assert(ios.width() == 0);
   2943                                 }
   2944                                 ios.width(25);
   2945                                 left(ios);
   2946                                 {
   2947                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2948                                     std::string ex(str, iter.base());
   2949                                     assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
   2950                                     assert(ios.width() == 0);
   2951                                 }
   2952                                 ios.width(25);
   2953                                 right(ios);
   2954                                 {
   2955                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2956                                     std::string ex(str, iter.base());
   2957                                     assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
   2958                                     assert(ios.width() == 0);
   2959                                 }
   2960                                 ios.width(25);
   2961                                 internal(ios);
   2962                                 {
   2963                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2964                                     std::string ex(str, iter.base());
   2965                                     assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
   2966                                     assert(ios.width() == 0);
   2967                                 }
   2968                             }
   2969                             ios.imbue(lg);
   2970                             {
   2971                                 ios.width(0);
   2972                                 {
   2973                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2974                                     std::string ex(str, iter.base());
   2975                                     assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
   2976                                     assert(ios.width() == 0);
   2977                                 }
   2978                                 ios.width(25);
   2979                                 left(ios);
   2980                                 {
   2981                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2982                                     std::string ex(str, iter.base());
   2983                                     assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
   2984                                     assert(ios.width() == 0);
   2985                                 }
   2986                                 ios.width(25);
   2987                                 right(ios);
   2988                                 {
   2989                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2990                                     std::string ex(str, iter.base());
   2991                                     assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
   2992                                     assert(ios.width() == 0);
   2993                                 }
   2994                                 ios.width(25);
   2995                                 internal(ios);
   2996                                 {
   2997                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2998                                     std::string ex(str, iter.base());
   2999                                     assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
   3000                                     assert(ios.width() == 0);
   3001                                 }
   3002                             }
   3003                         }
   3004                     }
   3005                 }
   3006             }
   3007         }
   3008     }
   3009 }
   3010 
   3011 void test2()
   3012 {
   3013     char str[200];
   3014     output_iterator<char*> iter;
   3015     std::locale lc = std::locale::classic();
   3016     std::locale lg(lc, new my_numpunct);
   3017     const my_facet f(1);
   3018     {
   3019         long double v = -0.;
   3020         std::ios ios(0);
   3021         // %g
   3022         {
   3023             ios.precision(0);
   3024             {
   3025                 nouppercase(ios);
   3026                 {
   3027                     noshowpos(ios);
   3028                     {
   3029                         noshowpoint(ios);
   3030                         {
   3031                             ios.imbue(lc);
   3032                             {
   3033                                 ios.width(0);
   3034                                 {
   3035                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3036                                     std::string ex(str, iter.base());
   3037                                     assert(ex == "-0");
   3038                                     assert(ios.width() == 0);
   3039                                 }
   3040                                 ios.width(25);
   3041                                 left(ios);
   3042                                 {
   3043                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3044                                     std::string ex(str, iter.base());
   3045                                     assert(ex == "-0***********************");
   3046                                     assert(ios.width() == 0);
   3047                                 }
   3048                                 ios.width(25);
   3049                                 right(ios);
   3050                                 {
   3051                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3052                                     std::string ex(str, iter.base());
   3053                                     assert(ex == "***********************-0");
   3054                                     assert(ios.width() == 0);
   3055                                 }
   3056                                 ios.width(25);
   3057                                 internal(ios);
   3058                                 {
   3059                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3060                                     std::string ex(str, iter.base());
   3061                                     assert(ex == "-***********************0");
   3062                                     assert(ios.width() == 0);
   3063                                 }
   3064                             }
   3065                             ios.imbue(lg);
   3066                             {
   3067                                 ios.width(0);
   3068                                 {
   3069                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3070                                     std::string ex(str, iter.base());
   3071                                     assert(ex == "-0");
   3072                                     assert(ios.width() == 0);
   3073                                 }
   3074                                 ios.width(25);
   3075                                 left(ios);
   3076                                 {
   3077                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3078                                     std::string ex(str, iter.base());
   3079                                     assert(ex == "-0***********************");
   3080                                     assert(ios.width() == 0);
   3081                                 }
   3082                                 ios.width(25);
   3083                                 right(ios);
   3084                                 {
   3085                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3086                                     std::string ex(str, iter.base());
   3087                                     assert(ex == "***********************-0");
   3088                                     assert(ios.width() == 0);
   3089                                 }
   3090                                 ios.width(25);
   3091                                 internal(ios);
   3092                                 {
   3093                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3094                                     std::string ex(str, iter.base());
   3095                                     assert(ex == "-***********************0");
   3096                                     assert(ios.width() == 0);
   3097                                 }
   3098                             }
   3099                         }
   3100                         showpoint(ios);
   3101                         {
   3102                             ios.imbue(lc);
   3103                             {
   3104                                 ios.width(0);
   3105                                 {
   3106                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3107                                     std::string ex(str, iter.base());
   3108                                     assert(ex == "-0.");
   3109                                     assert(ios.width() == 0);
   3110                                 }
   3111                                 ios.width(25);
   3112                                 left(ios);
   3113                                 {
   3114                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3115                                     std::string ex(str, iter.base());
   3116                                     assert(ex == "-0.**********************");
   3117                                     assert(ios.width() == 0);
   3118                                 }
   3119                                 ios.width(25);
   3120                                 right(ios);
   3121                                 {
   3122                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3123                                     std::string ex(str, iter.base());
   3124                                     assert(ex == "**********************-0.");
   3125                                     assert(ios.width() == 0);
   3126                                 }
   3127                                 ios.width(25);
   3128                                 internal(ios);
   3129                                 {
   3130                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3131                                     std::string ex(str, iter.base());
   3132                                     assert(ex == "-**********************0.");
   3133                                     assert(ios.width() == 0);
   3134                                 }
   3135                             }
   3136                             ios.imbue(lg);
   3137                             {
   3138                                 ios.width(0);
   3139                                 {
   3140                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3141                                     std::string ex(str, iter.base());
   3142                                     assert(ex == "-0;");
   3143                                     assert(ios.width() == 0);
   3144                                 }
   3145                                 ios.width(25);
   3146                                 left(ios);
   3147                                 {
   3148                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3149                                     std::string ex(str, iter.base());
   3150                                     assert(ex == "-0;**********************");
   3151                                     assert(ios.width() == 0);
   3152                                 }
   3153                                 ios.width(25);
   3154                                 right(ios);
   3155                                 {
   3156                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3157                                     std::string ex(str, iter.base());
   3158                                     assert(ex == "**********************-0;");
   3159                                     assert(ios.width() == 0);
   3160                                 }
   3161                                 ios.width(25);
   3162                                 internal(ios);
   3163                                 {
   3164                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3165                                     std::string ex(str, iter.base());
   3166                                     assert(ex == "-**********************0;");
   3167                                     assert(ios.width() == 0);
   3168                                 }
   3169                             }
   3170                         }
   3171                     }
   3172                     showpos(ios);
   3173                     {
   3174                         noshowpoint(ios);
   3175                         {
   3176                             ios.imbue(lc);
   3177                             {
   3178                                 ios.width(0);
   3179                                 {
   3180                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3181                                     std::string ex(str, iter.base());
   3182                                     assert(ex == "-0");
   3183                                     assert(ios.width() == 0);
   3184                                 }
   3185                                 ios.width(25);
   3186                                 left(ios);
   3187                                 {
   3188                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3189                                     std::string ex(str, iter.base());
   3190                                     assert(ex == "-0***********************");
   3191                                     assert(ios.width() == 0);
   3192                                 }
   3193                                 ios.width(25);
   3194                                 right(ios);
   3195                                 {
   3196                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3197                                     std::string ex(str, iter.base());
   3198                                     assert(ex == "***********************-0");
   3199                                     assert(ios.width() == 0);
   3200                                 }
   3201                                 ios.width(25);
   3202                                 internal(ios);
   3203                                 {
   3204                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3205                                     std::string ex(str, iter.base());
   3206                                     assert(ex == "-***********************0");
   3207                                     assert(ios.width() == 0);
   3208                                 }
   3209                             }
   3210                             ios.imbue(lg);
   3211                             {
   3212                                 ios.width(0);
   3213                                 {
   3214                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3215                                     std::string ex(str, iter.base());
   3216                                     assert(ex == "-0");
   3217                                     assert(ios.width() == 0);
   3218                                 }
   3219                                 ios.width(25);
   3220                                 left(ios);
   3221                                 {
   3222                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3223                                     std::string ex(str, iter.base());
   3224                                     assert(ex == "-0***********************");
   3225                                     assert(ios.width() == 0);
   3226                                 }
   3227                                 ios.width(25);
   3228                                 right(ios);
   3229                                 {
   3230                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3231                                     std::string ex(str, iter.base());
   3232                                     assert(ex == "***********************-0");
   3233                                     assert(ios.width() == 0);
   3234                                 }
   3235                                 ios.width(25);
   3236                                 internal(ios);
   3237                                 {
   3238                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3239                                     std::string ex(str, iter.base());
   3240                                     assert(ex == "-***********************0");
   3241                                     assert(ios.width() == 0);
   3242                                 }
   3243                             }
   3244                         }
   3245                         showpoint(ios);
   3246                         {
   3247                             ios.imbue(lc);
   3248                             {
   3249                                 ios.width(0);
   3250                                 {
   3251                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3252                                     std::string ex(str, iter.base());
   3253                                     assert(ex == "-0.");
   3254                                     assert(ios.width() == 0);
   3255                                 }
   3256                                 ios.width(25);
   3257                                 left(ios);
   3258                                 {
   3259                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3260                                     std::string ex(str, iter.base());
   3261                                     assert(ex == "-0.**********************");
   3262                                     assert(ios.width() == 0);
   3263                                 }
   3264                                 ios.width(25);
   3265                                 right(ios);
   3266                                 {
   3267                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3268                                     std::string ex(str, iter.base());
   3269                                     assert(ex == "**********************-0.");
   3270                                     assert(ios.width() == 0);
   3271                                 }
   3272                                 ios.width(25);
   3273                                 internal(ios);
   3274                                 {
   3275                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3276                                     std::string ex(str, iter.base());
   3277                                     assert(ex == "-**********************0.");
   3278                                     assert(ios.width() == 0);
   3279                                 }
   3280                             }
   3281                             ios.imbue(lg);
   3282                             {
   3283                                 ios.width(0);
   3284                                 {
   3285                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3286                                     std::string ex(str, iter.base());
   3287                                     assert(ex == "-0;");
   3288                                     assert(ios.width() == 0);
   3289                                 }
   3290                                 ios.width(25);
   3291                                 left(ios);
   3292                                 {
   3293                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3294                                     std::string ex(str, iter.base());
   3295                                     assert(ex == "-0;**********************");
   3296                                     assert(ios.width() == 0);
   3297                                 }
   3298                                 ios.width(25);
   3299                                 right(ios);
   3300                                 {
   3301                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3302                                     std::string ex(str, iter.base());
   3303                                     assert(ex == "**********************-0;");
   3304                                     assert(ios.width() == 0);
   3305                                 }
   3306                                 ios.width(25);
   3307                                 internal(ios);
   3308                                 {
   3309                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3310                                     std::string ex(str, iter.base());
   3311                                     assert(ex == "-**********************0;");
   3312                                     assert(ios.width() == 0);
   3313                                 }
   3314                             }
   3315                         }
   3316                     }
   3317                 }
   3318                 uppercase(ios);
   3319                 {
   3320                     noshowpos(ios);
   3321                     {
   3322                         noshowpoint(ios);
   3323                         {
   3324                             ios.imbue(lc);
   3325                             {
   3326                                 ios.width(0);
   3327                                 {
   3328                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3329                                     std::string ex(str, iter.base());
   3330                                     assert(ex == "-0");
   3331                                     assert(ios.width() == 0);
   3332                                 }
   3333                                 ios.width(25);
   3334                                 left(ios);
   3335                                 {
   3336                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3337                                     std::string ex(str, iter.base());
   3338                                     assert(ex == "-0***********************");
   3339                                     assert(ios.width() == 0);
   3340                                 }
   3341                                 ios.width(25);
   3342                                 right(ios);
   3343                                 {
   3344                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3345                                     std::string ex(str, iter.base());
   3346                                     assert(ex == "***********************-0");
   3347                                     assert(ios.width() == 0);
   3348                                 }
   3349                                 ios.width(25);
   3350                                 internal(ios);
   3351                                 {
   3352                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3353                                     std::string ex(str, iter.base());
   3354                                     assert(ex == "-***********************0");
   3355                                     assert(ios.width() == 0);
   3356                                 }
   3357                             }
   3358                             ios.imbue(lg);
   3359                             {
   3360                                 ios.width(0);
   3361                                 {
   3362                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3363                                     std::string ex(str, iter.base());
   3364                                     assert(ex == "-0");
   3365                                     assert(ios.width() == 0);
   3366                                 }
   3367                                 ios.width(25);
   3368                                 left(ios);
   3369                                 {
   3370                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3371                                     std::string ex(str, iter.base());
   3372                                     assert(ex == "-0***********************");
   3373                                     assert(ios.width() == 0);
   3374                                 }
   3375                                 ios.width(25);
   3376                                 right(ios);
   3377                                 {
   3378                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3379                                     std::string ex(str, iter.base());
   3380                                     assert(ex == "***********************-0");
   3381                                     assert(ios.width() == 0);
   3382                                 }
   3383                                 ios.width(25);
   3384                                 internal(ios);
   3385                                 {
   3386                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3387                                     std::string ex(str, iter.base());
   3388                                     assert(ex == "-***********************0");
   3389                                     assert(ios.width() == 0);
   3390                                 }
   3391                             }
   3392                         }
   3393                         showpoint(ios);
   3394                         {
   3395                             ios.imbue(lc);
   3396                             {
   3397                                 ios.width(0);
   3398                                 {
   3399                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3400                                     std::string ex(str, iter.base());
   3401                                     assert(ex == "-0.");
   3402                                     assert(ios.width() == 0);
   3403                                 }
   3404                                 ios.width(25);
   3405                                 left(ios);
   3406                                 {
   3407                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3408                                     std::string ex(str, iter.base());
   3409                                     assert(ex == "-0.**********************");
   3410                                     assert(ios.width() == 0);
   3411                                 }
   3412                                 ios.width(25);
   3413                                 right(ios);
   3414                                 {
   3415                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3416                                     std::string ex(str, iter.base());
   3417                                     assert(ex == "**********************-0.");
   3418                                     assert(ios.width() == 0);
   3419                                 }
   3420                                 ios.width(25);
   3421                                 internal(ios);
   3422                                 {
   3423                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3424                                     std::string ex(str, iter.base());
   3425                                     assert(ex == "-**********************0.");
   3426                                     assert(ios.width() == 0);
   3427                                 }
   3428                             }
   3429                             ios.imbue(lg);
   3430                             {
   3431                                 ios.width(0);
   3432                                 {
   3433                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3434                                     std::string ex(str, iter.base());
   3435                                     assert(ex == "-0;");
   3436                                     assert(ios.width() == 0);
   3437                                 }
   3438                                 ios.width(25);
   3439                                 left(ios);
   3440                                 {
   3441                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3442                                     std::string ex(str, iter.base());
   3443                                     assert(ex == "-0;**********************");
   3444                                     assert(ios.width() == 0);
   3445                                 }
   3446                                 ios.width(25);
   3447                                 right(ios);
   3448                                 {
   3449                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3450                                     std::string ex(str, iter.base());
   3451                                     assert(ex == "**********************-0;");
   3452                                     assert(ios.width() == 0);
   3453                                 }
   3454                                 ios.width(25);
   3455                                 internal(ios);
   3456                                 {
   3457                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3458                                     std::string ex(str, iter.base());
   3459                                     assert(ex == "-**********************0;");
   3460                                     assert(ios.width() == 0);
   3461                                 }
   3462                             }
   3463                         }
   3464                     }
   3465                     showpos(ios);
   3466                     {
   3467                         noshowpoint(ios);
   3468                         {
   3469                             ios.imbue(lc);
   3470                             {
   3471                                 ios.width(0);
   3472                                 {
   3473                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3474                                     std::string ex(str, iter.base());
   3475                                     assert(ex == "-0");
   3476                                     assert(ios.width() == 0);
   3477                                 }
   3478                                 ios.width(25);
   3479                                 left(ios);
   3480                                 {
   3481                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3482                                     std::string ex(str, iter.base());
   3483                                     assert(ex == "-0***********************");
   3484                                     assert(ios.width() == 0);
   3485                                 }
   3486                                 ios.width(25);
   3487                                 right(ios);
   3488                                 {
   3489                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3490                                     std::string ex(str, iter.base());
   3491                                     assert(ex == "***********************-0");
   3492                                     assert(ios.width() == 0);
   3493                                 }
   3494                                 ios.width(25);
   3495                                 internal(ios);
   3496                                 {
   3497                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3498                                     std::string ex(str, iter.base());
   3499                                     assert(ex == "-***********************0");
   3500                                     assert(ios.width() == 0);
   3501                                 }
   3502                             }
   3503                             ios.imbue(lg);
   3504                             {
   3505                                 ios.width(0);
   3506                                 {
   3507                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3508                                     std::string ex(str, iter.base());
   3509                                     assert(ex == "-0");
   3510                                     assert(ios.width() == 0);
   3511                                 }
   3512                                 ios.width(25);
   3513                                 left(ios);
   3514                                 {
   3515                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3516                                     std::string ex(str, iter.base());
   3517                                     assert(ex == "-0***********************");
   3518                                     assert(ios.width() == 0);
   3519                                 }
   3520                                 ios.width(25);
   3521                                 right(ios);
   3522                                 {
   3523                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3524                                     std::string ex(str, iter.base());
   3525                                     assert(ex == "***********************-0");
   3526                                     assert(ios.width() == 0);
   3527                                 }
   3528                                 ios.width(25);
   3529                                 internal(ios);
   3530                                 {
   3531                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3532                                     std::string ex(str, iter.base());
   3533                                     assert(ex == "-***********************0");
   3534                                     assert(ios.width() == 0);
   3535                                 }
   3536                             }
   3537                         }
   3538                         showpoint(ios);
   3539                         {
   3540                             ios.imbue(lc);
   3541                             {
   3542                                 ios.width(0);
   3543                                 {
   3544                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3545                                     std::string ex(str, iter.base());
   3546                                     assert(ex == "-0.");
   3547                                     assert(ios.width() == 0);
   3548                                 }
   3549                                 ios.width(25);
   3550                                 left(ios);
   3551                                 {
   3552                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3553                                     std::string ex(str, iter.base());
   3554                                     assert(ex == "-0.**********************");
   3555                                     assert(ios.width() == 0);
   3556                                 }
   3557                                 ios.width(25);
   3558                                 right(ios);
   3559                                 {
   3560                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3561                                     std::string ex(str, iter.base());
   3562                                     assert(ex == "**********************-0.");
   3563                                     assert(ios.width() == 0);
   3564                                 }
   3565                                 ios.width(25);
   3566                                 internal(ios);
   3567                                 {
   3568                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3569                                     std::string ex(str, iter.base());
   3570                                     assert(ex == "-**********************0.");
   3571                                     assert(ios.width() == 0);
   3572                                 }
   3573                             }
   3574                             ios.imbue(lg);
   3575                             {
   3576                                 ios.width(0);
   3577                                 {
   3578                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3579                                     std::string ex(str, iter.base());
   3580                                     assert(ex == "-0;");
   3581                                     assert(ios.width() == 0);
   3582                                 }
   3583                                 ios.width(25);
   3584                                 left(ios);
   3585                                 {
   3586                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3587                                     std::string ex(str, iter.base());
   3588                                     assert(ex == "-0;**********************");
   3589                                     assert(ios.width() == 0);
   3590                                 }
   3591                                 ios.width(25);
   3592                                 right(ios);
   3593                                 {
   3594                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3595                                     std::string ex(str, iter.base());
   3596                                     assert(ex == "**********************-0;");
   3597                                     assert(ios.width() == 0);
   3598                                 }
   3599                                 ios.width(25);
   3600                                 internal(ios);
   3601                                 {
   3602                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3603                                     std::string ex(str, iter.base());
   3604                                     assert(ex == "-**********************0;");
   3605                                     assert(ios.width() == 0);
   3606                                 }
   3607                             }
   3608                         }
   3609                     }
   3610                 }
   3611             }
   3612             ios.precision(1);
   3613             {
   3614                 nouppercase(ios);
   3615                 {
   3616                     noshowpos(ios);
   3617                     {
   3618                         noshowpoint(ios);
   3619                         {
   3620                             ios.imbue(lc);
   3621                             {
   3622                                 ios.width(0);
   3623                                 {
   3624                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3625                                     std::string ex(str, iter.base());
   3626                                     assert(ex == "-0");
   3627                                     assert(ios.width() == 0);
   3628                                 }
   3629                                 ios.width(25);
   3630                                 left(ios);
   3631                                 {
   3632                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3633                                     std::string ex(str, iter.base());
   3634                                     assert(ex == "-0***********************");
   3635                                     assert(ios.width() == 0);
   3636                                 }
   3637                                 ios.width(25);
   3638                                 right(ios);
   3639                                 {
   3640                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3641                                     std::string ex(str, iter.base());
   3642                                     assert(ex == "***********************-0");
   3643                                     assert(ios.width() == 0);
   3644                                 }
   3645                                 ios.width(25);
   3646                                 internal(ios);
   3647                                 {
   3648                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3649                                     std::string ex(str, iter.base());
   3650                                     assert(ex == "-***********************0");
   3651                                     assert(ios.width() == 0);
   3652                                 }
   3653                             }
   3654                             ios.imbue(lg);
   3655                             {
   3656                                 ios.width(0);
   3657                                 {
   3658                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3659                                     std::string ex(str, iter.base());
   3660                                     assert(ex == "-0");
   3661                                     assert(ios.width() == 0);
   3662                                 }
   3663                                 ios.width(25);
   3664                                 left(ios);
   3665                                 {
   3666                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3667                                     std::string ex(str, iter.base());
   3668                                     assert(ex == "-0***********************");
   3669                                     assert(ios.width() == 0);
   3670                                 }
   3671                                 ios.width(25);
   3672                                 right(ios);
   3673                                 {
   3674                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3675                                     std::string ex(str, iter.base());
   3676                                     assert(ex == "***********************-0");
   3677                                     assert(ios.width() == 0);
   3678                                 }
   3679                                 ios.width(25);
   3680                                 internal(ios);
   3681                                 {
   3682                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3683                                     std::string ex(str, iter.base());
   3684                                     assert(ex == "-***********************0");
   3685                                     assert(ios.width() == 0);
   3686                                 }
   3687                             }
   3688                         }
   3689                         showpoint(ios);
   3690                         {
   3691                             ios.imbue(lc);
   3692                             {
   3693                                 ios.width(0);
   3694                                 {
   3695                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3696                                     std::string ex(str, iter.base());
   3697                                     assert(ex == "-0.");
   3698                                     assert(ios.width() == 0);
   3699                                 }
   3700                                 ios.width(25);
   3701                                 left(ios);
   3702                                 {
   3703                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3704                                     std::string ex(str, iter.base());
   3705                                     assert(ex == "-0.**********************");
   3706                                     assert(ios.width() == 0);
   3707                                 }
   3708                                 ios.width(25);
   3709                                 right(ios);
   3710                                 {
   3711                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3712                                     std::string ex(str, iter.base());
   3713                                     assert(ex == "**********************-0.");
   3714                                     assert(ios.width() == 0);
   3715                                 }
   3716                                 ios.width(25);
   3717                                 internal(ios);
   3718                                 {
   3719                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3720                                     std::string ex(str, iter.base());
   3721                                     assert(ex == "-**********************0.");
   3722                                     assert(ios.width() == 0);
   3723                                 }
   3724                             }
   3725                             ios.imbue(lg);
   3726                             {
   3727                                 ios.width(0);
   3728                                 {
   3729                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3730                                     std::string ex(str, iter.base());
   3731                                     assert(ex == "-0;");
   3732                                     assert(ios.width() == 0);
   3733                                 }
   3734                                 ios.width(25);
   3735                                 left(ios);
   3736                                 {
   3737                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3738                                     std::string ex(str, iter.base());
   3739                                     assert(ex == "-0;**********************");
   3740                                     assert(ios.width() == 0);
   3741                                 }
   3742                                 ios.width(25);
   3743                                 right(ios);
   3744                                 {
   3745                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3746                                     std::string ex(str, iter.base());
   3747                                     assert(ex == "**********************-0;");
   3748                                     assert(ios.width() == 0);
   3749                                 }
   3750                                 ios.width(25);
   3751                                 internal(ios);
   3752                                 {
   3753                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3754                                     std::string ex(str, iter.base());
   3755                                     assert(ex == "-**********************0;");
   3756                                     assert(ios.width() == 0);
   3757                                 }
   3758                             }
   3759                         }
   3760                     }
   3761                     showpos(ios);
   3762                     {
   3763                         noshowpoint(ios);
   3764                         {
   3765                             ios.imbue(lc);
   3766                             {
   3767                                 ios.width(0);
   3768                                 {
   3769                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3770                                     std::string ex(str, iter.base());
   3771                                     assert(ex == "-0");
   3772                                     assert(ios.width() == 0);
   3773                                 }
   3774                                 ios.width(25);
   3775                                 left(ios);
   3776                                 {
   3777                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3778                                     std::string ex(str, iter.base());
   3779                                     assert(ex == "-0***********************");
   3780                                     assert(ios.width() == 0);
   3781                                 }
   3782                                 ios.width(25);
   3783                                 right(ios);
   3784                                 {
   3785                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3786                                     std::string ex(str, iter.base());
   3787                                     assert(ex == "***********************-0");
   3788                                     assert(ios.width() == 0);
   3789                                 }
   3790                                 ios.width(25);
   3791                                 internal(ios);
   3792                                 {
   3793                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3794                                     std::string ex(str, iter.base());
   3795                                     assert(ex == "-***********************0");
   3796                                     assert(ios.width() == 0);
   3797                                 }
   3798                             }
   3799                             ios.imbue(lg);
   3800                             {
   3801                                 ios.width(0);
   3802                                 {
   3803                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3804                                     std::string ex(str, iter.base());
   3805                                     assert(ex == "-0");
   3806                                     assert(ios.width() == 0);
   3807                                 }
   3808                                 ios.width(25);
   3809                                 left(ios);
   3810                                 {
   3811                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3812                                     std::string ex(str, iter.base());
   3813                                     assert(ex == "-0***********************");
   3814                                     assert(ios.width() == 0);
   3815                                 }
   3816                                 ios.width(25);
   3817                                 right(ios);
   3818                                 {
   3819                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3820                                     std::string ex(str, iter.base());
   3821                                     assert(ex == "***********************-0");
   3822                                     assert(ios.width() == 0);
   3823                                 }
   3824                                 ios.width(25);
   3825                                 internal(ios);
   3826                                 {
   3827                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3828                                     std::string ex(str, iter.base());
   3829                                     assert(ex == "-***********************0");
   3830                                     assert(ios.width() == 0);
   3831                                 }
   3832                             }
   3833                         }
   3834                         showpoint(ios);
   3835                         {
   3836                             ios.imbue(lc);
   3837                             {
   3838                                 ios.width(0);
   3839                                 {
   3840                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3841                                     std::string ex(str, iter.base());
   3842                                     assert(ex == "-0.");
   3843                                     assert(ios.width() == 0);
   3844                                 }
   3845                                 ios.width(25);
   3846                                 left(ios);
   3847                                 {
   3848                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3849                                     std::string ex(str, iter.base());
   3850                                     assert(ex == "-0.**********************");
   3851                                     assert(ios.width() == 0);
   3852                                 }
   3853                                 ios.width(25);
   3854                                 right(ios);
   3855                                 {
   3856                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3857                                     std::string ex(str, iter.base());
   3858                                     assert(ex == "**********************-0.");
   3859                                     assert(ios.width() == 0);
   3860                                 }
   3861                                 ios.width(25);
   3862                                 internal(ios);
   3863                                 {
   3864                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3865                                     std::string ex(str, iter.base());
   3866                                     assert(ex == "-**********************0.");
   3867                                     assert(ios.width() == 0);
   3868                                 }
   3869                             }
   3870                             ios.imbue(lg);
   3871                             {
   3872                                 ios.width(0);
   3873                                 {
   3874                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3875                                     std::string ex(str, iter.base());
   3876                                     assert(ex == "-0;");
   3877                                     assert(ios.width() == 0);
   3878                                 }
   3879                                 ios.width(25);
   3880                                 left(ios);
   3881                                 {
   3882                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3883                                     std::string ex(str, iter.base());
   3884                                     assert(ex == "-0;**********************");
   3885                                     assert(ios.width() == 0);
   3886                                 }
   3887                                 ios.width(25);
   3888                                 right(ios);
   3889                                 {
   3890                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3891                                     std::string ex(str, iter.base());
   3892                                     assert(ex == "**********************-0;");
   3893                                     assert(ios.width() == 0);
   3894                                 }
   3895                                 ios.width(25);
   3896                                 internal(ios);
   3897                                 {
   3898                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3899                                     std::string ex(str, iter.base());
   3900                                     assert(ex == "-**********************0;");
   3901                                     assert(ios.width() == 0);
   3902                                 }
   3903                             }
   3904                         }
   3905                     }
   3906                 }
   3907                 uppercase(ios);
   3908                 {
   3909                     noshowpos(ios);
   3910                     {
   3911                         noshowpoint(ios);
   3912                         {
   3913                             ios.imbue(lc);
   3914                             {
   3915                                 ios.width(0);
   3916                                 {
   3917                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3918                                     std::string ex(str, iter.base());
   3919                                     assert(ex == "-0");
   3920                                     assert(ios.width() == 0);
   3921                                 }
   3922                                 ios.width(25);
   3923                                 left(ios);
   3924                                 {
   3925                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3926                                     std::string ex(str, iter.base());
   3927                                     assert(ex == "-0***********************");
   3928                                     assert(ios.width() == 0);
   3929                                 }
   3930                                 ios.width(25);
   3931                                 right(ios);
   3932                                 {
   3933                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3934                                     std::string ex(str, iter.base());
   3935                                     assert(ex == "***********************-0");
   3936                                     assert(ios.width() == 0);
   3937                                 }
   3938                                 ios.width(25);
   3939                                 internal(ios);
   3940                                 {
   3941                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3942                                     std::string ex(str, iter.base());
   3943                                     assert(ex == "-***********************0");
   3944                                     assert(ios.width() == 0);
   3945                                 }
   3946                             }
   3947                             ios.imbue(lg);
   3948                             {
   3949                                 ios.width(0);
   3950                                 {
   3951                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3952                                     std::string ex(str, iter.base());
   3953                                     assert(ex == "-0");
   3954                                     assert(ios.width() == 0);
   3955                                 }
   3956                                 ios.width(25);
   3957                                 left(ios);
   3958                                 {
   3959                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3960                                     std::string ex(str, iter.base());
   3961                                     assert(ex == "-0***********************");
   3962                                     assert(ios.width() == 0);
   3963                                 }
   3964                                 ios.width(25);
   3965                                 right(ios);
   3966                                 {
   3967                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3968                                     std::string ex(str, iter.base());
   3969                                     assert(ex == "***********************-0");
   3970                                     assert(ios.width() == 0);
   3971                                 }
   3972                                 ios.width(25);
   3973                                 internal(ios);
   3974                                 {
   3975                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3976                                     std::string ex(str, iter.base());
   3977                                     assert(ex == "-***********************0");
   3978                                     assert(ios.width() == 0);
   3979                                 }
   3980                             }
   3981                         }
   3982                         showpoint(ios);
   3983                         {
   3984                             ios.imbue(lc);
   3985                             {
   3986                                 ios.width(0);
   3987                                 {
   3988                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3989                                     std::string ex(str, iter.base());
   3990                                     assert(ex == "-0.");
   3991                                     assert(ios.width() == 0);
   3992                                 }
   3993                                 ios.width(25);
   3994                                 left(ios);
   3995                                 {
   3996                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3997                                     std::string ex(str, iter.base());
   3998                                     assert(ex == "-0.**********************");
   3999                                     assert(ios.width() == 0);
   4000                                 }
   4001                                 ios.width(25);
   4002                                 right(ios);
   4003                                 {
   4004                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4005                                     std::string ex(str, iter.base());
   4006                                     assert(ex == "**********************-0.");
   4007                                     assert(ios.width() == 0);
   4008                                 }
   4009                                 ios.width(25);
   4010                                 internal(ios);
   4011                                 {
   4012                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4013                                     std::string ex(str, iter.base());
   4014                                     assert(ex == "-**********************0.");
   4015                                     assert(ios.width() == 0);
   4016                                 }
   4017                             }
   4018                             ios.imbue(lg);
   4019                             {
   4020                                 ios.width(0);
   4021                                 {
   4022                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4023                                     std::string ex(str, iter.base());
   4024                                     assert(ex == "-0;");
   4025                                     assert(ios.width() == 0);
   4026                                 }
   4027                                 ios.width(25);
   4028                                 left(ios);
   4029                                 {
   4030                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4031                                     std::string ex(str, iter.base());
   4032                                     assert(ex == "-0;**********************");
   4033                                     assert(ios.width() == 0);
   4034                                 }
   4035                                 ios.width(25);
   4036                                 right(ios);
   4037                                 {
   4038                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4039                                     std::string ex(str, iter.base());
   4040                                     assert(ex == "**********************-0;");
   4041                                     assert(ios.width() == 0);
   4042                                 }
   4043                                 ios.width(25);
   4044                                 internal(ios);
   4045                                 {
   4046                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4047                                     std::string ex(str, iter.base());
   4048                                     assert(ex == "-**********************0;");
   4049                                     assert(ios.width() == 0);
   4050                                 }
   4051                             }
   4052                         }
   4053                     }
   4054                     showpos(ios);
   4055                     {
   4056                         noshowpoint(ios);
   4057                         {
   4058                             ios.imbue(lc);
   4059                             {
   4060                                 ios.width(0);
   4061                                 {
   4062                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4063                                     std::string ex(str, iter.base());
   4064                                     assert(ex == "-0");
   4065                                     assert(ios.width() == 0);
   4066                                 }
   4067                                 ios.width(25);
   4068                                 left(ios);
   4069                                 {
   4070                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4071                                     std::string ex(str, iter.base());
   4072                                     assert(ex == "-0***********************");
   4073                                     assert(ios.width() == 0);
   4074                                 }
   4075                                 ios.width(25);
   4076                                 right(ios);
   4077                                 {
   4078                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4079                                     std::string ex(str, iter.base());
   4080                                     assert(ex == "***********************-0");
   4081                                     assert(ios.width() == 0);
   4082                                 }
   4083                                 ios.width(25);
   4084                                 internal(ios);
   4085                                 {
   4086                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4087                                     std::string ex(str, iter.base());
   4088                                     assert(ex == "-***********************0");
   4089                                     assert(ios.width() == 0);
   4090                                 }
   4091                             }
   4092                             ios.imbue(lg);
   4093                             {
   4094                                 ios.width(0);
   4095                                 {
   4096                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4097                                     std::string ex(str, iter.base());
   4098                                     assert(ex == "-0");
   4099                                     assert(ios.width() == 0);
   4100                                 }
   4101                                 ios.width(25);
   4102                                 left(ios);
   4103                                 {
   4104                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4105                                     std::string ex(str, iter.base());
   4106                                     assert(ex == "-0***********************");
   4107                                     assert(ios.width() == 0);
   4108                                 }
   4109                                 ios.width(25);
   4110                                 right(ios);
   4111                                 {
   4112                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4113                                     std::string ex(str, iter.base());
   4114                                     assert(ex == "***********************-0");
   4115                                     assert(ios.width() == 0);
   4116                                 }
   4117                                 ios.width(25);
   4118                                 internal(ios);
   4119                                 {
   4120                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4121                                     std::string ex(str, iter.base());
   4122                                     assert(ex == "-***********************0");
   4123                                     assert(ios.width() == 0);
   4124                                 }
   4125                             }
   4126                         }
   4127                         showpoint(ios);
   4128                         {
   4129                             ios.imbue(lc);
   4130                             {
   4131                                 ios.width(0);
   4132                                 {
   4133                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4134                                     std::string ex(str, iter.base());
   4135                                     assert(ex == "-0.");
   4136                                     assert(ios.width() == 0);
   4137                                 }
   4138                                 ios.width(25);
   4139                                 left(ios);
   4140                                 {
   4141                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4142                                     std::string ex(str, iter.base());
   4143                                     assert(ex == "-0.**********************");
   4144                                     assert(ios.width() == 0);
   4145                                 }
   4146                                 ios.width(25);
   4147                                 right(ios);
   4148                                 {
   4149                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4150                                     std::string ex(str, iter.base());
   4151                                     assert(ex == "**********************-0.");
   4152                                     assert(ios.width() == 0);
   4153                                 }
   4154                                 ios.width(25);
   4155                                 internal(ios);
   4156                                 {
   4157                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4158                                     std::string ex(str, iter.base());
   4159                                     assert(ex == "-**********************0.");
   4160                                     assert(ios.width() == 0);
   4161                                 }
   4162                             }
   4163                             ios.imbue(lg);
   4164                             {
   4165                                 ios.width(0);
   4166                                 {
   4167                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4168                                     std::string ex(str, iter.base());
   4169                                     assert(ex == "-0;");
   4170                                     assert(ios.width() == 0);
   4171                                 }
   4172                                 ios.width(25);
   4173                                 left(ios);
   4174                                 {
   4175                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4176                                     std::string ex(str, iter.base());
   4177                                     assert(ex == "-0;**********************");
   4178                                     assert(ios.width() == 0);
   4179                                 }
   4180                                 ios.width(25);
   4181                                 right(ios);
   4182                                 {
   4183                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4184                                     std::string ex(str, iter.base());
   4185                                     assert(ex == "**********************-0;");
   4186                                     assert(ios.width() == 0);
   4187                                 }
   4188                                 ios.width(25);
   4189                                 internal(ios);
   4190                                 {
   4191                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4192                                     std::string ex(str, iter.base());
   4193                                     assert(ex == "-**********************0;");
   4194                                     assert(ios.width() == 0);
   4195                                 }
   4196                             }
   4197                         }
   4198                     }
   4199                 }
   4200             }
   4201             ios.precision(6);
   4202             {
   4203                 nouppercase(ios);
   4204                 {
   4205                     noshowpos(ios);
   4206                     {
   4207                         noshowpoint(ios);
   4208                         {
   4209                             ios.imbue(lc);
   4210                             {
   4211                                 ios.width(0);
   4212                                 {
   4213                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4214                                     std::string ex(str, iter.base());
   4215                                     assert(ex == "-0");
   4216                                     assert(ios.width() == 0);
   4217                                 }
   4218                                 ios.width(25);
   4219                                 left(ios);
   4220                                 {
   4221                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4222                                     std::string ex(str, iter.base());
   4223                                     assert(ex == "-0***********************");
   4224                                     assert(ios.width() == 0);
   4225                                 }
   4226                                 ios.width(25);
   4227                                 right(ios);
   4228                                 {
   4229                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4230                                     std::string ex(str, iter.base());
   4231                                     assert(ex == "***********************-0");
   4232                                     assert(ios.width() == 0);
   4233                                 }
   4234                                 ios.width(25);
   4235                                 internal(ios);
   4236                                 {
   4237                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4238                                     std::string ex(str, iter.base());
   4239                                     assert(ex == "-***********************0");
   4240                                     assert(ios.width() == 0);
   4241                                 }
   4242                             }
   4243                             ios.imbue(lg);
   4244                             {
   4245                                 ios.width(0);
   4246                                 {
   4247                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4248                                     std::string ex(str, iter.base());
   4249                                     assert(ex == "-0");
   4250                                     assert(ios.width() == 0);
   4251                                 }
   4252                                 ios.width(25);
   4253                                 left(ios);
   4254                                 {
   4255                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4256                                     std::string ex(str, iter.base());
   4257                                     assert(ex == "-0***********************");
   4258                                     assert(ios.width() == 0);
   4259                                 }
   4260                                 ios.width(25);
   4261                                 right(ios);
   4262                                 {
   4263                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4264                                     std::string ex(str, iter.base());
   4265                                     assert(ex == "***********************-0");
   4266                                     assert(ios.width() == 0);
   4267                                 }
   4268                                 ios.width(25);
   4269                                 internal(ios);
   4270                                 {
   4271                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4272                                     std::string ex(str, iter.base());
   4273                                     assert(ex == "-***********************0");
   4274                                     assert(ios.width() == 0);
   4275                                 }
   4276                             }
   4277                         }
   4278                         showpoint(ios);
   4279                         {
   4280                             ios.imbue(lc);
   4281                             {
   4282                                 ios.width(0);
   4283                                 {
   4284                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4285                                     std::string ex(str, iter.base());
   4286                                     assert(ex == "-0.00000");
   4287                                     assert(ios.width() == 0);
   4288                                 }
   4289                                 ios.width(25);
   4290                                 left(ios);
   4291                                 {
   4292                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4293                                     std::string ex(str, iter.base());
   4294                                     assert(ex == "-0.00000*****************");
   4295                                     assert(ios.width() == 0);
   4296                                 }
   4297                                 ios.width(25);
   4298                                 right(ios);
   4299                                 {
   4300                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4301                                     std::string ex(str, iter.base());
   4302                                     assert(ex == "*****************-0.00000");
   4303                                     assert(ios.width() == 0);
   4304                                 }
   4305                                 ios.width(25);
   4306                                 internal(ios);
   4307                                 {
   4308                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4309                                     std::string ex(str, iter.base());
   4310                                     assert(ex == "-*****************0.00000");
   4311                                     assert(ios.width() == 0);
   4312                                 }
   4313                             }
   4314                             ios.imbue(lg);
   4315                             {
   4316                                 ios.width(0);
   4317                                 {
   4318                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4319                                     std::string ex(str, iter.base());
   4320                                     assert(ex == "-0;00000");
   4321                                     assert(ios.width() == 0);
   4322                                 }
   4323                                 ios.width(25);
   4324                                 left(ios);
   4325                                 {
   4326                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4327                                     std::string ex(str, iter.base());
   4328                                     assert(ex == "-0;00000*****************");
   4329                                     assert(ios.width() == 0);
   4330                                 }
   4331                                 ios.width(25);
   4332                                 right(ios);
   4333                                 {
   4334                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4335                                     std::string ex(str, iter.base());
   4336                                     assert(ex == "*****************-0;00000");
   4337                                     assert(ios.width() == 0);
   4338                                 }
   4339                                 ios.width(25);
   4340                                 internal(ios);
   4341                                 {
   4342                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4343                                     std::string ex(str, iter.base());
   4344                                     assert(ex == "-*****************0;00000");
   4345                                     assert(ios.width() == 0);
   4346                                 }
   4347                             }
   4348                         }
   4349                     }
   4350                     showpos(ios);
   4351                     {
   4352                         noshowpoint(ios);
   4353                         {
   4354                             ios.imbue(lc);
   4355                             {
   4356                                 ios.width(0);
   4357                                 {
   4358                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4359                                     std::string ex(str, iter.base());
   4360                                     assert(ex == "-0");
   4361                                     assert(ios.width() == 0);
   4362                                 }
   4363                                 ios.width(25);
   4364                                 left(ios);
   4365                                 {
   4366                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4367                                     std::string ex(str, iter.base());
   4368                                     assert(ex == "-0***********************");
   4369                                     assert(ios.width() == 0);
   4370                                 }
   4371                                 ios.width(25);
   4372                                 right(ios);
   4373                                 {
   4374                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4375                                     std::string ex(str, iter.base());
   4376                                     assert(ex == "***********************-0");
   4377                                     assert(ios.width() == 0);
   4378                                 }
   4379                                 ios.width(25);
   4380                                 internal(ios);
   4381                                 {
   4382                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4383                                     std::string ex(str, iter.base());
   4384                                     assert(ex == "-***********************0");
   4385                                     assert(ios.width() == 0);
   4386                                 }
   4387                             }
   4388                             ios.imbue(lg);
   4389                             {
   4390                                 ios.width(0);
   4391                                 {
   4392                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4393                                     std::string ex(str, iter.base());
   4394                                     assert(ex == "-0");
   4395                                     assert(ios.width() == 0);
   4396                                 }
   4397                                 ios.width(25);
   4398                                 left(ios);
   4399                                 {
   4400                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4401                                     std::string ex(str, iter.base());
   4402                                     assert(ex == "-0***********************");
   4403                                     assert(ios.width() == 0);
   4404                                 }
   4405                                 ios.width(25);
   4406                                 right(ios);
   4407                                 {
   4408                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4409                                     std::string ex(str, iter.base());
   4410                                     assert(ex == "***********************-0");
   4411                                     assert(ios.width() == 0);
   4412                                 }
   4413                                 ios.width(25);
   4414                                 internal(ios);
   4415                                 {
   4416                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4417                                     std::string ex(str, iter.base());
   4418                                     assert(ex == "-***********************0");
   4419                                     assert(ios.width() == 0);
   4420                                 }
   4421                             }
   4422                         }
   4423                         showpoint(ios);
   4424                         {
   4425                             ios.imbue(lc);
   4426                             {
   4427                                 ios.width(0);
   4428                                 {
   4429                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4430                                     std::string ex(str, iter.base());
   4431                                     assert(ex == "-0.00000");
   4432                                     assert(ios.width() == 0);
   4433                                 }
   4434                                 ios.width(25);
   4435                                 left(ios);
   4436                                 {
   4437                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4438                                     std::string ex(str, iter.base());
   4439                                     assert(ex == "-0.00000*****************");
   4440                                     assert(ios.width() == 0);
   4441                                 }
   4442                                 ios.width(25);
   4443                                 right(ios);
   4444                                 {
   4445                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4446                                     std::string ex(str, iter.base());
   4447                                     assert(ex == "*****************-0.00000");
   4448                                     assert(ios.width() == 0);
   4449                                 }
   4450                                 ios.width(25);
   4451                                 internal(ios);
   4452                                 {
   4453                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4454                                     std::string ex(str, iter.base());
   4455                                     assert(ex == "-*****************0.00000");
   4456                                     assert(ios.width() == 0);
   4457                                 }
   4458                             }
   4459                             ios.imbue(lg);
   4460                             {
   4461                                 ios.width(0);
   4462                                 {
   4463                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4464                                     std::string ex(str, iter.base());
   4465                                     assert(ex == "-0;00000");
   4466                                     assert(ios.width() == 0);
   4467                                 }
   4468                                 ios.width(25);
   4469                                 left(ios);
   4470                                 {
   4471                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4472                                     std::string ex(str, iter.base());
   4473                                     assert(ex == "-0;00000*****************");
   4474                                     assert(ios.width() == 0);
   4475                                 }
   4476                                 ios.width(25);
   4477                                 right(ios);
   4478                                 {
   4479                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4480                                     std::string ex(str, iter.base());
   4481                                     assert(ex == "*****************-0;00000");
   4482                                     assert(ios.width() == 0);
   4483                                 }
   4484                                 ios.width(25);
   4485                                 internal(ios);
   4486                                 {
   4487                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4488                                     std::string ex(str, iter.base());
   4489                                     assert(ex == "-*****************0;00000");
   4490                                     assert(ios.width() == 0);
   4491                                 }
   4492                             }
   4493                         }
   4494                     }
   4495                 }
   4496                 uppercase(ios);
   4497                 {
   4498                     noshowpos(ios);
   4499                     {
   4500                         noshowpoint(ios);
   4501                         {
   4502                             ios.imbue(lc);
   4503                             {
   4504                                 ios.width(0);
   4505                                 {
   4506                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4507                                     std::string ex(str, iter.base());
   4508                                     assert(ex == "-0");
   4509                                     assert(ios.width() == 0);
   4510                                 }
   4511                                 ios.width(25);
   4512                                 left(ios);
   4513                                 {
   4514                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4515                                     std::string ex(str, iter.base());
   4516                                     assert(ex == "-0***********************");
   4517                                     assert(ios.width() == 0);
   4518                                 }
   4519                                 ios.width(25);
   4520                                 right(ios);
   4521                                 {
   4522                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4523                                     std::string ex(str, iter.base());
   4524                                     assert(ex == "***********************-0");
   4525                                     assert(ios.width() == 0);
   4526                                 }
   4527                                 ios.width(25);
   4528                                 internal(ios);
   4529                                 {
   4530                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4531                                     std::string ex(str, iter.base());
   4532                                     assert(ex == "-***********************0");
   4533                                     assert(ios.width() == 0);
   4534                                 }
   4535                             }
   4536                             ios.imbue(lg);
   4537                             {
   4538                                 ios.width(0);
   4539                                 {
   4540                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4541                                     std::string ex(str, iter.base());
   4542                                     assert(ex == "-0");
   4543                                     assert(ios.width() == 0);
   4544                                 }
   4545                                 ios.width(25);
   4546                                 left(ios);
   4547                                 {
   4548                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4549                                     std::string ex(str, iter.base());
   4550                                     assert(ex == "-0***********************");
   4551                                     assert(ios.width() == 0);
   4552                                 }
   4553                                 ios.width(25);
   4554                                 right(ios);
   4555                                 {
   4556                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4557                                     std::string ex(str, iter.base());
   4558                                     assert(ex == "***********************-0");
   4559                                     assert(ios.width() == 0);
   4560                                 }
   4561                                 ios.width(25);
   4562                                 internal(ios);
   4563                                 {
   4564                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4565                                     std::string ex(str, iter.base());
   4566                                     assert(ex == "-***********************0");
   4567                                     assert(ios.width() == 0);
   4568                                 }
   4569                             }
   4570                         }
   4571                         showpoint(ios);
   4572                         {
   4573                             ios.imbue(lc);
   4574                             {
   4575                                 ios.width(0);
   4576                                 {
   4577                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4578                                     std::string ex(str, iter.base());
   4579                                     assert(ex == "-0.00000");
   4580                                     assert(ios.width() == 0);
   4581                                 }
   4582                                 ios.width(25);
   4583                                 left(ios);
   4584                                 {
   4585                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4586                                     std::string ex(str, iter.base());
   4587                                     assert(ex == "-0.00000*****************");
   4588                                     assert(ios.width() == 0);
   4589                                 }
   4590                                 ios.width(25);
   4591                                 right(ios);
   4592                                 {
   4593                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4594                                     std::string ex(str, iter.base());
   4595                                     assert(ex == "*****************-0.00000");
   4596                                     assert(ios.width() == 0);
   4597                                 }
   4598                                 ios.width(25);
   4599                                 internal(ios);
   4600                                 {
   4601                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4602                                     std::string ex(str, iter.base());
   4603                                     assert(ex == "-*****************0.00000");
   4604                                     assert(ios.width() == 0);
   4605                                 }
   4606                             }
   4607                             ios.imbue(lg);
   4608                             {
   4609                                 ios.width(0);
   4610                                 {
   4611                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4612                                     std::string ex(str, iter.base());
   4613                                     assert(ex == "-0;00000");
   4614                                     assert(ios.width() == 0);
   4615                                 }
   4616                                 ios.width(25);
   4617                                 left(ios);
   4618                                 {
   4619                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4620                                     std::string ex(str, iter.base());
   4621                                     assert(ex == "-0;00000*****************");
   4622                                     assert(ios.width() == 0);
   4623                                 }
   4624                                 ios.width(25);
   4625                                 right(ios);
   4626                                 {
   4627                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4628                                     std::string ex(str, iter.base());
   4629                                     assert(ex == "*****************-0;00000");
   4630                                     assert(ios.width() == 0);
   4631                                 }
   4632                                 ios.width(25);
   4633                                 internal(ios);
   4634                                 {
   4635                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4636                                     std::string ex(str, iter.base());
   4637                                     assert(ex == "-*****************0;00000");
   4638                                     assert(ios.width() == 0);
   4639                                 }
   4640                             }
   4641                         }
   4642                     }
   4643                     showpos(ios);
   4644                     {
   4645                         noshowpoint(ios);
   4646                         {
   4647                             ios.imbue(lc);
   4648                             {
   4649                                 ios.width(0);
   4650                                 {
   4651                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4652                                     std::string ex(str, iter.base());
   4653                                     assert(ex == "-0");
   4654                                     assert(ios.width() == 0);
   4655                                 }
   4656                                 ios.width(25);
   4657                                 left(ios);
   4658                                 {
   4659                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4660                                     std::string ex(str, iter.base());
   4661                                     assert(ex == "-0***********************");
   4662                                     assert(ios.width() == 0);
   4663                                 }
   4664                                 ios.width(25);
   4665                                 right(ios);
   4666                                 {
   4667                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4668                                     std::string ex(str, iter.base());
   4669                                     assert(ex == "***********************-0");
   4670                                     assert(ios.width() == 0);
   4671                                 }
   4672                                 ios.width(25);
   4673                                 internal(ios);
   4674                                 {
   4675                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4676                                     std::string ex(str, iter.base());
   4677                                     assert(ex == "-***********************0");
   4678                                     assert(ios.width() == 0);
   4679                                 }
   4680                             }
   4681                             ios.imbue(lg);
   4682                             {
   4683                                 ios.width(0);
   4684                                 {
   4685                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4686                                     std::string ex(str, iter.base());
   4687                                     assert(ex == "-0");
   4688                                     assert(ios.width() == 0);
   4689                                 }
   4690                                 ios.width(25);
   4691                                 left(ios);
   4692                                 {
   4693                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4694                                     std::string ex(str, iter.base());
   4695                                     assert(ex == "-0***********************");
   4696                                     assert(ios.width() == 0);
   4697                                 }
   4698                                 ios.width(25);
   4699                                 right(ios);
   4700                                 {
   4701                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4702                                     std::string ex(str, iter.base());
   4703                                     assert(ex == "***********************-0");
   4704                                     assert(ios.width() == 0);
   4705                                 }
   4706                                 ios.width(25);
   4707                                 internal(ios);
   4708                                 {
   4709                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4710                                     std::string ex(str, iter.base());
   4711                                     assert(ex == "-***********************0");
   4712                                     assert(ios.width() == 0);
   4713                                 }
   4714                             }
   4715                         }
   4716                         showpoint(ios);
   4717                         {
   4718                             ios.imbue(lc);
   4719                             {
   4720                                 ios.width(0);
   4721                                 {
   4722                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4723                                     std::string ex(str, iter.base());
   4724                                     assert(ex == "-0.00000");
   4725                                     assert(ios.width() == 0);
   4726                                 }
   4727                                 ios.width(25);
   4728                                 left(ios);
   4729                                 {
   4730                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4731                                     std::string ex(str, iter.base());
   4732                                     assert(ex == "-0.00000*****************");
   4733                                     assert(ios.width() == 0);
   4734                                 }
   4735                                 ios.width(25);
   4736                                 right(ios);
   4737                                 {
   4738                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4739                                     std::string ex(str, iter.base());
   4740                                     assert(ex == "*****************-0.00000");
   4741                                     assert(ios.width() == 0);
   4742                                 }
   4743                                 ios.width(25);
   4744                                 internal(ios);
   4745                                 {
   4746                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4747                                     std::string ex(str, iter.base());
   4748                                     assert(ex == "-*****************0.00000");
   4749                                     assert(ios.width() == 0);
   4750                                 }
   4751                             }
   4752                             ios.imbue(lg);
   4753                             {
   4754                                 ios.width(0);
   4755                                 {
   4756                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4757                                     std::string ex(str, iter.base());
   4758                                     assert(ex == "-0;00000");
   4759                                     assert(ios.width() == 0);
   4760                                 }
   4761                                 ios.width(25);
   4762                                 left(ios);
   4763                                 {
   4764                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4765                                     std::string ex(str, iter.base());
   4766                                     assert(ex == "-0;00000*****************");
   4767                                     assert(ios.width() == 0);
   4768                                 }
   4769                                 ios.width(25);
   4770                                 right(ios);
   4771                                 {
   4772                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4773                                     std::string ex(str, iter.base());
   4774                                     assert(ex == "*****************-0;00000");
   4775                                     assert(ios.width() == 0);
   4776                                 }
   4777                                 ios.width(25);
   4778                                 internal(ios);
   4779                                 {
   4780                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4781                                     std::string ex(str, iter.base());
   4782                                     assert(ex == "-*****************0;00000");
   4783                                     assert(ios.width() == 0);
   4784                                 }
   4785                             }
   4786                         }
   4787                     }
   4788                 }
   4789             }
   4790             ios.precision(16);
   4791             {
   4792                 nouppercase(ios);
   4793                 {
   4794                     noshowpos(ios);
   4795                     {
   4796                         noshowpoint(ios);
   4797                         {
   4798                             ios.imbue(lc);
   4799                             {
   4800                                 ios.width(0);
   4801                                 {
   4802                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4803                                     std::string ex(str, iter.base());
   4804                                     assert(ex == "-0");
   4805                                     assert(ios.width() == 0);
   4806                                 }
   4807                                 ios.width(25);
   4808                                 left(ios);
   4809                                 {
   4810                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4811                                     std::string ex(str, iter.base());
   4812                                     assert(ex == "-0***********************");
   4813                                     assert(ios.width() == 0);
   4814                                 }
   4815                                 ios.width(25);
   4816                                 right(ios);
   4817                                 {
   4818                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4819                                     std::string ex(str, iter.base());
   4820                                     assert(ex == "***********************-0");
   4821                                     assert(ios.width() == 0);
   4822                                 }
   4823                                 ios.width(25);
   4824                                 internal(ios);
   4825                                 {
   4826                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4827                                     std::string ex(str, iter.base());
   4828                                     assert(ex == "-***********************0");
   4829                                     assert(ios.width() == 0);
   4830                                 }
   4831                             }
   4832                             ios.imbue(lg);
   4833                             {
   4834                                 ios.width(0);
   4835                                 {
   4836                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4837                                     std::string ex(str, iter.base());
   4838                                     assert(ex == "-0");
   4839                                     assert(ios.width() == 0);
   4840                                 }
   4841                                 ios.width(25);
   4842                                 left(ios);
   4843                                 {
   4844                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4845                                     std::string ex(str, iter.base());
   4846                                     assert(ex == "-0***********************");
   4847                                     assert(ios.width() == 0);
   4848                                 }
   4849                                 ios.width(25);
   4850                                 right(ios);
   4851                                 {
   4852                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4853                                     std::string ex(str, iter.base());
   4854                                     assert(ex == "***********************-0");
   4855                                     assert(ios.width() == 0);
   4856                                 }
   4857                                 ios.width(25);
   4858                                 internal(ios);
   4859                                 {
   4860                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4861                                     std::string ex(str, iter.base());
   4862                                     assert(ex == "-***********************0");
   4863                                     assert(ios.width() == 0);
   4864                                 }
   4865                             }
   4866                         }
   4867                         showpoint(ios);
   4868                         {
   4869                             ios.imbue(lc);
   4870                             {
   4871                                 ios.width(0);
   4872                                 {
   4873                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4874                                     std::string ex(str, iter.base());
   4875                                     assert(ex == "-0.000000000000000");
   4876                                     assert(ios.width() == 0);
   4877                                 }
   4878                                 ios.width(25);
   4879                                 left(ios);
   4880                                 {
   4881                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4882                                     std::string ex(str, iter.base());
   4883                                     assert(ex == "-0.000000000000000*******");
   4884                                     assert(ios.width() == 0);
   4885                                 }
   4886                                 ios.width(25);
   4887                                 right(ios);
   4888                                 {
   4889                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4890                                     std::string ex(str, iter.base());
   4891                                     assert(ex == "*******-0.000000000000000");
   4892                                     assert(ios.width() == 0);
   4893                                 }
   4894                                 ios.width(25);
   4895                                 internal(ios);
   4896                                 {
   4897                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4898                                     std::string ex(str, iter.base());
   4899                                     assert(ex == "-*******0.000000000000000");
   4900                                     assert(ios.width() == 0);
   4901                                 }
   4902                             }
   4903                             ios.imbue(lg);
   4904                             {
   4905                                 ios.width(0);
   4906                                 {
   4907                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4908                                     std::string ex(str, iter.base());
   4909                                     assert(ex == "-0;000000000000000");
   4910                                     assert(ios.width() == 0);
   4911                                 }
   4912                                 ios.width(25);
   4913                                 left(ios);
   4914                                 {
   4915                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4916                                     std::string ex(str, iter.base());
   4917                                     assert(ex == "-0;000000000000000*******");
   4918                                     assert(ios.width() == 0);
   4919                                 }
   4920                                 ios.width(25);
   4921                                 right(ios);
   4922                                 {
   4923                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4924                                     std::string ex(str, iter.base());
   4925                                     assert(ex == "*******-0;000000000000000");
   4926                                     assert(ios.width() == 0);
   4927                                 }
   4928                                 ios.width(25);
   4929                                 internal(ios);
   4930                                 {
   4931                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4932                                     std::string ex(str, iter.base());
   4933                                     assert(ex == "-*******0;000000000000000");
   4934                                     assert(ios.width() == 0);
   4935                                 }
   4936                             }
   4937                         }
   4938                     }
   4939                     showpos(ios);
   4940                     {
   4941                         noshowpoint(ios);
   4942                         {
   4943                             ios.imbue(lc);
   4944                             {
   4945                                 ios.width(0);
   4946                                 {
   4947                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4948                                     std::string ex(str, iter.base());
   4949                                     assert(ex == "-0");
   4950                                     assert(ios.width() == 0);
   4951                                 }
   4952                                 ios.width(25);
   4953                                 left(ios);
   4954                                 {
   4955                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4956                                     std::string ex(str, iter.base());
   4957                                     assert(ex == "-0***********************");
   4958                                     assert(ios.width() == 0);
   4959                                 }
   4960                                 ios.width(25);
   4961                                 right(ios);
   4962                                 {
   4963                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4964                                     std::string ex(str, iter.base());
   4965                                     assert(ex == "***********************-0");
   4966                                     assert(ios.width() == 0);
   4967                                 }
   4968                                 ios.width(25);
   4969                                 internal(ios);
   4970                                 {
   4971                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4972                                     std::string ex(str, iter.base());
   4973                                     assert(ex == "-***********************0");
   4974                                     assert(ios.width() == 0);
   4975                                 }
   4976                             }
   4977                             ios.imbue(lg);
   4978                             {
   4979                                 ios.width(0);
   4980                                 {
   4981                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4982                                     std::string ex(str, iter.base());
   4983                                     assert(ex == "-0");
   4984                                     assert(ios.width() == 0);
   4985                                 }
   4986                                 ios.width(25);
   4987                                 left(ios);
   4988                                 {
   4989                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4990                                     std::string ex(str, iter.base());
   4991                                     assert(ex == "-0***********************");
   4992                                     assert(ios.width() == 0);
   4993                                 }
   4994                                 ios.width(25);
   4995                                 right(ios);
   4996                                 {
   4997                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4998                                     std::string ex(str, iter.base());
   4999                                     assert(ex == "***********************-0");
   5000                                     assert(ios.width() == 0);
   5001                                 }
   5002                                 ios.width(25);
   5003                                 internal(ios);
   5004                                 {
   5005                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5006                                     std::string ex(str, iter.base());
   5007                                     assert(ex == "-***********************0");
   5008                                     assert(ios.width() == 0);
   5009                                 }
   5010                             }
   5011                         }
   5012                         showpoint(ios);
   5013                         {
   5014                             ios.imbue(lc);
   5015                             {
   5016                                 ios.width(0);
   5017                                 {
   5018                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5019                                     std::string ex(str, iter.base());
   5020                                     assert(ex == "-0.000000000000000");
   5021                                     assert(ios.width() == 0);
   5022                                 }
   5023                                 ios.width(25);
   5024                                 left(ios);
   5025                                 {
   5026                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5027                                     std::string ex(str, iter.base());
   5028                                     assert(ex == "-0.000000000000000*******");
   5029                                     assert(ios.width() == 0);
   5030                                 }
   5031                                 ios.width(25);
   5032                                 right(ios);
   5033                                 {
   5034                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5035                                     std::string ex(str, iter.base());
   5036                                     assert(ex == "*******-0.000000000000000");
   5037                                     assert(ios.width() == 0);
   5038                                 }
   5039                                 ios.width(25);
   5040                                 internal(ios);
   5041                                 {
   5042                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5043                                     std::string ex(str, iter.base());
   5044                                     assert(ex == "-*******0.000000000000000");
   5045                                     assert(ios.width() == 0);
   5046                                 }
   5047                             }
   5048                             ios.imbue(lg);
   5049                             {
   5050                                 ios.width(0);
   5051                                 {
   5052                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5053                                     std::string ex(str, iter.base());
   5054                                     assert(ex == "-0;000000000000000");
   5055                                     assert(ios.width() == 0);
   5056                                 }
   5057                                 ios.width(25);
   5058                                 left(ios);
   5059                                 {
   5060                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5061                                     std::string ex(str, iter.base());
   5062                                     assert(ex == "-0;000000000000000*******");
   5063                                     assert(ios.width() == 0);
   5064                                 }
   5065                                 ios.width(25);
   5066                                 right(ios);
   5067                                 {
   5068                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5069                                     std::string ex(str, iter.base());
   5070                                     assert(ex == "*******-0;000000000000000");
   5071                                     assert(ios.width() == 0);
   5072                                 }
   5073                                 ios.width(25);
   5074                                 internal(ios);
   5075                                 {
   5076                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5077                                     std::string ex(str, iter.base());
   5078                                     assert(ex == "-*******0;000000000000000");
   5079                                     assert(ios.width() == 0);
   5080                                 }
   5081                             }
   5082                         }
   5083                     }
   5084                 }
   5085                 uppercase(ios);
   5086                 {
   5087                     noshowpos(ios);
   5088                     {
   5089                         noshowpoint(ios);
   5090                         {
   5091                             ios.imbue(lc);
   5092                             {
   5093                                 ios.width(0);
   5094                                 {
   5095                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5096                                     std::string ex(str, iter.base());
   5097                                     assert(ex == "-0");
   5098                                     assert(ios.width() == 0);
   5099                                 }
   5100                                 ios.width(25);
   5101                                 left(ios);
   5102                                 {
   5103                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5104                                     std::string ex(str, iter.base());
   5105                                     assert(ex == "-0***********************");
   5106                                     assert(ios.width() == 0);
   5107                                 }
   5108                                 ios.width(25);
   5109                                 right(ios);
   5110                                 {
   5111                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5112                                     std::string ex(str, iter.base());
   5113                                     assert(ex == "***********************-0");
   5114                                     assert(ios.width() == 0);
   5115                                 }
   5116                                 ios.width(25);
   5117                                 internal(ios);
   5118                                 {
   5119                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5120                                     std::string ex(str, iter.base());
   5121                                     assert(ex == "-***********************0");
   5122                                     assert(ios.width() == 0);
   5123                                 }
   5124                             }
   5125                             ios.imbue(lg);
   5126                             {
   5127                                 ios.width(0);
   5128                                 {
   5129                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5130                                     std::string ex(str, iter.base());
   5131                                     assert(ex == "-0");
   5132                                     assert(ios.width() == 0);
   5133                                 }
   5134                                 ios.width(25);
   5135                                 left(ios);
   5136                                 {
   5137                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5138                                     std::string ex(str, iter.base());
   5139                                     assert(ex == "-0***********************");
   5140                                     assert(ios.width() == 0);
   5141                                 }
   5142                                 ios.width(25);
   5143                                 right(ios);
   5144                                 {
   5145                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5146                                     std::string ex(str, iter.base());
   5147                                     assert(ex == "***********************-0");
   5148                                     assert(ios.width() == 0);
   5149                                 }
   5150                                 ios.width(25);
   5151                                 internal(ios);
   5152                                 {
   5153                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5154                                     std::string ex(str, iter.base());
   5155                                     assert(ex == "-***********************0");
   5156                                     assert(ios.width() == 0);
   5157                                 }
   5158                             }
   5159                         }
   5160                         showpoint(ios);
   5161                         {
   5162                             ios.imbue(lc);
   5163                             {
   5164                                 ios.width(0);
   5165                                 {
   5166                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5167                                     std::string ex(str, iter.base());
   5168                                     assert(ex == "-0.000000000000000");
   5169                                     assert(ios.width() == 0);
   5170                                 }
   5171                                 ios.width(25);
   5172                                 left(ios);
   5173                                 {
   5174                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5175                                     std::string ex(str, iter.base());
   5176                                     assert(ex == "-0.000000000000000*******");
   5177                                     assert(ios.width() == 0);
   5178                                 }
   5179                                 ios.width(25);
   5180                                 right(ios);
   5181                                 {
   5182                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5183                                     std::string ex(str, iter.base());
   5184                                     assert(ex == "*******-0.000000000000000");
   5185                                     assert(ios.width() == 0);
   5186                                 }
   5187                                 ios.width(25);
   5188                                 internal(ios);
   5189                                 {
   5190                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5191                                     std::string ex(str, iter.base());
   5192                                     assert(ex == "-*******0.000000000000000");
   5193                                     assert(ios.width() == 0);
   5194                                 }
   5195                             }
   5196                             ios.imbue(lg);
   5197                             {
   5198                                 ios.width(0);
   5199                                 {
   5200                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5201                                     std::string ex(str, iter.base());
   5202                                     assert(ex == "-0;000000000000000");
   5203                                     assert(ios.width() == 0);
   5204                                 }
   5205                                 ios.width(25);
   5206                                 left(ios);
   5207                                 {
   5208                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5209                                     std::string ex(str, iter.base());
   5210                                     assert(ex == "-0;000000000000000*******");
   5211                                     assert(ios.width() == 0);
   5212                                 }
   5213                                 ios.width(25);
   5214                                 right(ios);
   5215                                 {
   5216                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5217                                     std::string ex(str, iter.base());
   5218                                     assert(ex == "*******-0;000000000000000");
   5219                                     assert(ios.width() == 0);
   5220                                 }
   5221                                 ios.width(25);
   5222                                 internal(ios);
   5223                                 {
   5224                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5225                                     std::string ex(str, iter.base());
   5226                                     assert(ex == "-*******0;000000000000000");
   5227                                     assert(ios.width() == 0);
   5228                                 }
   5229                             }
   5230                         }
   5231                     }
   5232                     showpos(ios);
   5233                     {
   5234                         noshowpoint(ios);
   5235                         {
   5236                             ios.imbue(lc);
   5237                             {
   5238                                 ios.width(0);
   5239                                 {
   5240                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5241                                     std::string ex(str, iter.base());
   5242                                     assert(ex == "-0");
   5243                                     assert(ios.width() == 0);
   5244                                 }
   5245                                 ios.width(25);
   5246                                 left(ios);
   5247                                 {
   5248                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5249                                     std::string ex(str, iter.base());
   5250                                     assert(ex == "-0***********************");
   5251                                     assert(ios.width() == 0);
   5252                                 }
   5253                                 ios.width(25);
   5254                                 right(ios);
   5255                                 {
   5256                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5257                                     std::string ex(str, iter.base());
   5258                                     assert(ex == "***********************-0");
   5259                                     assert(ios.width() == 0);
   5260                                 }
   5261                                 ios.width(25);
   5262                                 internal(ios);
   5263                                 {
   5264                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5265                                     std::string ex(str, iter.base());
   5266                                     assert(ex == "-***********************0");
   5267                                     assert(ios.width() == 0);
   5268                                 }
   5269                             }
   5270                             ios.imbue(lg);
   5271                             {
   5272                                 ios.width(0);
   5273                                 {
   5274                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5275                                     std::string ex(str, iter.base());
   5276                                     assert(ex == "-0");
   5277                                     assert(ios.width() == 0);
   5278                                 }
   5279                                 ios.width(25);
   5280                                 left(ios);
   5281                                 {
   5282                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5283                                     std::string ex(str, iter.base());
   5284                                     assert(ex == "-0***********************");
   5285                                     assert(ios.width() == 0);
   5286                                 }
   5287                                 ios.width(25);
   5288                                 right(ios);
   5289                                 {
   5290                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5291                                     std::string ex(str, iter.base());
   5292                                     assert(ex == "***********************-0");
   5293                                     assert(ios.width() == 0);
   5294                                 }
   5295                                 ios.width(25);
   5296                                 internal(ios);
   5297                                 {
   5298                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5299                                     std::string ex(str, iter.base());
   5300                                     assert(ex == "-***********************0");
   5301                                     assert(ios.width() == 0);
   5302                                 }
   5303                             }
   5304                         }
   5305                         showpoint(ios);
   5306                         {
   5307                             ios.imbue(lc);
   5308                             {
   5309                                 ios.width(0);
   5310                                 {
   5311                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5312                                     std::string ex(str, iter.base());
   5313                                     assert(ex == "-0.000000000000000");
   5314                                     assert(ios.width() == 0);
   5315                                 }
   5316                                 ios.width(25);
   5317                                 left(ios);
   5318                                 {
   5319                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5320                                     std::string ex(str, iter.base());
   5321                                     assert(ex == "-0.000000000000000*******");
   5322                                     assert(ios.width() == 0);
   5323                                 }
   5324                                 ios.width(25);
   5325                                 right(ios);
   5326                                 {
   5327                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5328                                     std::string ex(str, iter.base());
   5329                                     assert(ex == "*******-0.000000000000000");
   5330                                     assert(ios.width() == 0);
   5331                                 }
   5332                                 ios.width(25);
   5333                                 internal(ios);
   5334                                 {
   5335                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5336                                     std::string ex(str, iter.base());
   5337                                     assert(ex == "-*******0.000000000000000");
   5338                                     assert(ios.width() == 0);
   5339                                 }
   5340                             }
   5341                             ios.imbue(lg);
   5342                             {
   5343                                 ios.width(0);
   5344                                 {
   5345                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5346                                     std::string ex(str, iter.base());
   5347                                     assert(ex == "-0;000000000000000");
   5348                                     assert(ios.width() == 0);
   5349                                 }
   5350                                 ios.width(25);
   5351                                 left(ios);
   5352                                 {
   5353                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5354                                     std::string ex(str, iter.base());
   5355                                     assert(ex == "-0;000000000000000*******");
   5356                                     assert(ios.width() == 0);
   5357                                 }
   5358                                 ios.width(25);
   5359                                 right(ios);
   5360                                 {
   5361                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5362                                     std::string ex(str, iter.base());
   5363                                     assert(ex == "*******-0;000000000000000");
   5364                                     assert(ios.width() == 0);
   5365                                 }
   5366                                 ios.width(25);
   5367                                 internal(ios);
   5368                                 {
   5369                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5370                                     std::string ex(str, iter.base());
   5371                                     assert(ex == "-*******0;000000000000000");
   5372                                     assert(ios.width() == 0);
   5373                                 }
   5374                             }
   5375                         }
   5376                     }
   5377                 }
   5378             }
   5379             ios.precision(60);
   5380             {
   5381                 nouppercase(ios);
   5382                 {
   5383                     noshowpos(ios);
   5384                     {
   5385                         noshowpoint(ios);
   5386                         {
   5387                             ios.imbue(lc);
   5388                             {
   5389                                 ios.width(0);
   5390                                 {
   5391                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5392                                     std::string ex(str, iter.base());
   5393                                     assert(ex == "-0");
   5394                                     assert(ios.width() == 0);
   5395                                 }
   5396                                 ios.width(25);
   5397                                 left(ios);
   5398                                 {
   5399                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5400                                     std::string ex(str, iter.base());
   5401                                     assert(ex == "-0***********************");
   5402                                     assert(ios.width() == 0);
   5403                                 }
   5404                                 ios.width(25);
   5405                                 right(ios);
   5406                                 {
   5407                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5408                                     std::string ex(str, iter.base());
   5409                                     assert(ex == "***********************-0");
   5410                                     assert(ios.width() == 0);
   5411                                 }
   5412                                 ios.width(25);
   5413                                 internal(ios);
   5414                                 {
   5415                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5416                                     std::string ex(str, iter.base());
   5417                                     assert(ex == "-***********************0");
   5418                                     assert(ios.width() == 0);
   5419                                 }
   5420                             }
   5421                             ios.imbue(lg);
   5422                             {
   5423                                 ios.width(0);
   5424                                 {
   5425                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5426                                     std::string ex(str, iter.base());
   5427                                     assert(ex == "-0");
   5428                                     assert(ios.width() == 0);
   5429                                 }
   5430                                 ios.width(25);
   5431                                 left(ios);
   5432                                 {
   5433                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5434                                     std::string ex(str, iter.base());
   5435                                     assert(ex == "-0***********************");
   5436                                     assert(ios.width() == 0);
   5437                                 }
   5438                                 ios.width(25);
   5439                                 right(ios);
   5440                                 {
   5441                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5442                                     std::string ex(str, iter.base());
   5443                                     assert(ex == "***********************-0");
   5444                                     assert(ios.width() == 0);
   5445                                 }
   5446                                 ios.width(25);
   5447                                 internal(ios);
   5448                                 {
   5449                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5450                                     std::string ex(str, iter.base());
   5451                                     assert(ex == "-***********************0");
   5452                                     assert(ios.width() == 0);
   5453                                 }
   5454                             }
   5455                         }
   5456                         showpoint(ios);
   5457                         {
   5458                             ios.imbue(lc);
   5459                             {
   5460                                 ios.width(0);
   5461                                 {
   5462                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5463                                     std::string ex(str, iter.base());
   5464                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5465                                     assert(ios.width() == 0);
   5466                                 }
   5467                                 ios.width(25);
   5468                                 left(ios);
   5469                                 {
   5470                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5471                                     std::string ex(str, iter.base());
   5472                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5473                                     assert(ios.width() == 0);
   5474                                 }
   5475                                 ios.width(25);
   5476                                 right(ios);
   5477                                 {
   5478                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5479                                     std::string ex(str, iter.base());
   5480                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5481                                     assert(ios.width() == 0);
   5482                                 }
   5483                                 ios.width(25);
   5484                                 internal(ios);
   5485                                 {
   5486                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5487                                     std::string ex(str, iter.base());
   5488                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5489                                     assert(ios.width() == 0);
   5490                                 }
   5491                             }
   5492                             ios.imbue(lg);
   5493                             {
   5494                                 ios.width(0);
   5495                                 {
   5496                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5497                                     std::string ex(str, iter.base());
   5498                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5499                                     assert(ios.width() == 0);
   5500                                 }
   5501                                 ios.width(25);
   5502                                 left(ios);
   5503                                 {
   5504                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5505                                     std::string ex(str, iter.base());
   5506                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5507                                     assert(ios.width() == 0);
   5508                                 }
   5509                                 ios.width(25);
   5510                                 right(ios);
   5511                                 {
   5512                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5513                                     std::string ex(str, iter.base());
   5514                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5515                                     assert(ios.width() == 0);
   5516                                 }
   5517                                 ios.width(25);
   5518                                 internal(ios);
   5519                                 {
   5520                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5521                                     std::string ex(str, iter.base());
   5522                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5523                                     assert(ios.width() == 0);
   5524                                 }
   5525                             }
   5526                         }
   5527                     }
   5528                     showpos(ios);
   5529                     {
   5530                         noshowpoint(ios);
   5531                         {
   5532                             ios.imbue(lc);
   5533                             {
   5534                                 ios.width(0);
   5535                                 {
   5536                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5537                                     std::string ex(str, iter.base());
   5538                                     assert(ex == "-0");
   5539                                     assert(ios.width() == 0);
   5540                                 }
   5541                                 ios.width(25);
   5542                                 left(ios);
   5543                                 {
   5544                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5545                                     std::string ex(str, iter.base());
   5546                                     assert(ex == "-0***********************");
   5547                                     assert(ios.width() == 0);
   5548                                 }
   5549                                 ios.width(25);
   5550                                 right(ios);
   5551                                 {
   5552                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5553                                     std::string ex(str, iter.base());
   5554                                     assert(ex == "***********************-0");
   5555                                     assert(ios.width() == 0);
   5556                                 }
   5557                                 ios.width(25);
   5558                                 internal(ios);
   5559                                 {
   5560                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5561                                     std::string ex(str, iter.base());
   5562                                     assert(ex == "-***********************0");
   5563                                     assert(ios.width() == 0);
   5564                                 }
   5565                             }
   5566                             ios.imbue(lg);
   5567                             {
   5568                                 ios.width(0);
   5569                                 {
   5570                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5571                                     std::string ex(str, iter.base());
   5572                                     assert(ex == "-0");
   5573                                     assert(ios.width() == 0);
   5574                                 }
   5575                                 ios.width(25);
   5576                                 left(ios);
   5577                                 {
   5578                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5579                                     std::string ex(str, iter.base());
   5580                                     assert(ex == "-0***********************");
   5581                                     assert(ios.width() == 0);
   5582                                 }
   5583                                 ios.width(25);
   5584                                 right(ios);
   5585                                 {
   5586                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5587                                     std::string ex(str, iter.base());
   5588                                     assert(ex == "***********************-0");
   5589                                     assert(ios.width() == 0);
   5590                                 }
   5591                                 ios.width(25);
   5592                                 internal(ios);
   5593                                 {
   5594                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5595                                     std::string ex(str, iter.base());
   5596                                     assert(ex == "-***********************0");
   5597                                     assert(ios.width() == 0);
   5598                                 }
   5599                             }
   5600                         }
   5601                         showpoint(ios);
   5602                         {
   5603                             ios.imbue(lc);
   5604                             {
   5605                                 ios.width(0);
   5606                                 {
   5607                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5608                                     std::string ex(str, iter.base());
   5609                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5610                                     assert(ios.width() == 0);
   5611                                 }
   5612                                 ios.width(25);
   5613                                 left(ios);
   5614                                 {
   5615                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5616                                     std::string ex(str, iter.base());
   5617                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5618                                     assert(ios.width() == 0);
   5619                                 }
   5620                                 ios.width(25);
   5621                                 right(ios);
   5622                                 {
   5623                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5624                                     std::string ex(str, iter.base());
   5625                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5626                                     assert(ios.width() == 0);
   5627                                 }
   5628                                 ios.width(25);
   5629                                 internal(ios);
   5630                                 {
   5631                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5632                                     std::string ex(str, iter.base());
   5633                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5634                                     assert(ios.width() == 0);
   5635                                 }
   5636                             }
   5637                             ios.imbue(lg);
   5638                             {
   5639                                 ios.width(0);
   5640                                 {
   5641                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5642                                     std::string ex(str, iter.base());
   5643                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5644                                     assert(ios.width() == 0);
   5645                                 }
   5646                                 ios.width(25);
   5647                                 left(ios);
   5648                                 {
   5649                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5650                                     std::string ex(str, iter.base());
   5651                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5652                                     assert(ios.width() == 0);
   5653                                 }
   5654                                 ios.width(25);
   5655                                 right(ios);
   5656                                 {
   5657                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5658                                     std::string ex(str, iter.base());
   5659                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5660                                     assert(ios.width() == 0);
   5661                                 }
   5662                                 ios.width(25);
   5663                                 internal(ios);
   5664                                 {
   5665                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5666                                     std::string ex(str, iter.base());
   5667                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5668                                     assert(ios.width() == 0);
   5669                                 }
   5670                             }
   5671                         }
   5672                     }
   5673                 }
   5674                 uppercase(ios);
   5675                 {
   5676                     noshowpos(ios);
   5677                     {
   5678                         noshowpoint(ios);
   5679                         {
   5680                             ios.imbue(lc);
   5681                             {
   5682                                 ios.width(0);
   5683                                 {
   5684                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5685                                     std::string ex(str, iter.base());
   5686                                     assert(ex == "-0");
   5687                                     assert(ios.width() == 0);
   5688                                 }
   5689                                 ios.width(25);
   5690                                 left(ios);
   5691                                 {
   5692                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5693                                     std::string ex(str, iter.base());
   5694                                     assert(ex == "-0***********************");
   5695                                     assert(ios.width() == 0);
   5696                                 }
   5697                                 ios.width(25);
   5698                                 right(ios);
   5699                                 {
   5700                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5701                                     std::string ex(str, iter.base());
   5702                                     assert(ex == "***********************-0");
   5703                                     assert(ios.width() == 0);
   5704                                 }
   5705                                 ios.width(25);
   5706                                 internal(ios);
   5707                                 {
   5708                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5709                                     std::string ex(str, iter.base());
   5710                                     assert(ex == "-***********************0");
   5711                                     assert(ios.width() == 0);
   5712                                 }
   5713                             }
   5714                             ios.imbue(lg);
   5715                             {
   5716                                 ios.width(0);
   5717                                 {
   5718                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5719                                     std::string ex(str, iter.base());
   5720                                     assert(ex == "-0");
   5721                                     assert(ios.width() == 0);
   5722                                 }
   5723                                 ios.width(25);
   5724                                 left(ios);
   5725                                 {
   5726                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5727                                     std::string ex(str, iter.base());
   5728                                     assert(ex == "-0***********************");
   5729                                     assert(ios.width() == 0);
   5730                                 }
   5731                                 ios.width(25);
   5732                                 right(ios);
   5733                                 {
   5734                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5735                                     std::string ex(str, iter.base());
   5736                                     assert(ex == "***********************-0");
   5737                                     assert(ios.width() == 0);
   5738                                 }
   5739                                 ios.width(25);
   5740                                 internal(ios);
   5741                                 {
   5742                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5743                                     std::string ex(str, iter.base());
   5744                                     assert(ex == "-***********************0");
   5745                                     assert(ios.width() == 0);
   5746                                 }
   5747                             }
   5748                         }
   5749                         showpoint(ios);
   5750                         {
   5751                             ios.imbue(lc);
   5752                             {
   5753                                 ios.width(0);
   5754                                 {
   5755                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5756                                     std::string ex(str, iter.base());
   5757                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5758                                     assert(ios.width() == 0);
   5759                                 }
   5760                                 ios.width(25);
   5761                                 left(ios);
   5762                                 {
   5763                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5764                                     std::string ex(str, iter.base());
   5765                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5766                                     assert(ios.width() == 0);
   5767                                 }
   5768                                 ios.width(25);
   5769                                 right(ios);
   5770                                 {
   5771                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5772                                     std::string ex(str, iter.base());
   5773                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5774                                     assert(ios.width() == 0);
   5775                                 }
   5776                                 ios.width(25);
   5777                                 internal(ios);
   5778                                 {
   5779                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5780                                     std::string ex(str, iter.base());
   5781                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5782                                     assert(ios.width() == 0);
   5783                                 }
   5784                             }
   5785                             ios.imbue(lg);
   5786                             {
   5787                                 ios.width(0);
   5788                                 {
   5789                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5790                                     std::string ex(str, iter.base());
   5791                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5792                                     assert(ios.width() == 0);
   5793                                 }
   5794                                 ios.width(25);
   5795                                 left(ios);
   5796                                 {
   5797                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5798                                     std::string ex(str, iter.base());
   5799                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5800                                     assert(ios.width() == 0);
   5801                                 }
   5802                                 ios.width(25);
   5803                                 right(ios);
   5804                                 {
   5805                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5806                                     std::string ex(str, iter.base());
   5807                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5808                                     assert(ios.width() == 0);
   5809                                 }
   5810                                 ios.width(25);
   5811                                 internal(ios);
   5812                                 {
   5813                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5814                                     std::string ex(str, iter.base());
   5815                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5816                                     assert(ios.width() == 0);
   5817                                 }
   5818                             }
   5819                         }
   5820                     }
   5821                     showpos(ios);
   5822                     {
   5823                         noshowpoint(ios);
   5824                         {
   5825                             ios.imbue(lc);
   5826                             {
   5827                                 ios.width(0);
   5828                                 {
   5829                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5830                                     std::string ex(str, iter.base());
   5831                                     assert(ex == "-0");
   5832                                     assert(ios.width() == 0);
   5833                                 }
   5834                                 ios.width(25);
   5835                                 left(ios);
   5836                                 {
   5837                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5838                                     std::string ex(str, iter.base());
   5839                                     assert(ex == "-0***********************");
   5840                                     assert(ios.width() == 0);
   5841                                 }
   5842                                 ios.width(25);
   5843                                 right(ios);
   5844                                 {
   5845                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5846                                     std::string ex(str, iter.base());
   5847                                     assert(ex == "***********************-0");
   5848                                     assert(ios.width() == 0);
   5849                                 }
   5850                                 ios.width(25);
   5851                                 internal(ios);
   5852                                 {
   5853                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5854                                     std::string ex(str, iter.base());
   5855                                     assert(ex == "-***********************0");
   5856                                     assert(ios.width() == 0);
   5857                                 }
   5858                             }
   5859                             ios.imbue(lg);
   5860                             {
   5861                                 ios.width(0);
   5862                                 {
   5863                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5864                                     std::string ex(str, iter.base());
   5865                                     assert(ex == "-0");
   5866                                     assert(ios.width() == 0);
   5867                                 }
   5868                                 ios.width(25);
   5869                                 left(ios);
   5870                                 {
   5871                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5872                                     std::string ex(str, iter.base());
   5873                                     assert(ex == "-0***********************");
   5874                                     assert(ios.width() == 0);
   5875                                 }
   5876                                 ios.width(25);
   5877                                 right(ios);
   5878                                 {
   5879                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5880                                     std::string ex(str, iter.base());
   5881                                     assert(ex == "***********************-0");
   5882                                     assert(ios.width() == 0);
   5883                                 }
   5884                                 ios.width(25);
   5885                                 internal(ios);
   5886                                 {
   5887                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5888                                     std::string ex(str, iter.base());
   5889                                     assert(ex == "-***********************0");
   5890                                     assert(ios.width() == 0);
   5891                                 }
   5892                             }
   5893                         }
   5894                         showpoint(ios);
   5895                         {
   5896                             ios.imbue(lc);
   5897                             {
   5898                                 ios.width(0);
   5899                                 {
   5900                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5901                                     std::string ex(str, iter.base());
   5902                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5903                                     assert(ios.width() == 0);
   5904                                 }
   5905                                 ios.width(25);
   5906                                 left(ios);
   5907                                 {
   5908                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5909                                     std::string ex(str, iter.base());
   5910                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5911                                     assert(ios.width() == 0);
   5912                                 }
   5913                                 ios.width(25);
   5914                                 right(ios);
   5915                                 {
   5916                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5917                                     std::string ex(str, iter.base());
   5918                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5919                                     assert(ios.width() == 0);
   5920                                 }
   5921                                 ios.width(25);
   5922                                 internal(ios);
   5923                                 {
   5924                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5925                                     std::string ex(str, iter.base());
   5926                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5927                                     assert(ios.width() == 0);
   5928                                 }
   5929                             }
   5930                             ios.imbue(lg);
   5931                             {
   5932                                 ios.width(0);
   5933                                 {
   5934                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5935                                     std::string ex(str, iter.base());
   5936                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5937                                     assert(ios.width() == 0);
   5938                                 }
   5939                                 ios.width(25);
   5940                                 left(ios);
   5941                                 {
   5942                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5943                                     std::string ex(str, iter.base());
   5944                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5945                                     assert(ios.width() == 0);
   5946                                 }
   5947                                 ios.width(25);
   5948                                 right(ios);
   5949                                 {
   5950                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5951                                     std::string ex(str, iter.base());
   5952                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5953                                     assert(ios.width() == 0);
   5954                                 }
   5955                                 ios.width(25);
   5956                                 internal(ios);
   5957                                 {
   5958                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5959                                     std::string ex(str, iter.base());
   5960                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5961                                     assert(ios.width() == 0);
   5962                                 }
   5963                             }
   5964                         }
   5965                     }
   5966                 }
   5967             }
   5968         }
   5969     }
   5970 }
   5971 
   5972 void test3()
   5973 {
   5974     char str[200];
   5975     output_iterator<char*> iter;
   5976     std::locale lc = std::locale::classic();
   5977     std::locale lg(lc, new my_numpunct);
   5978     const my_facet f(1);
   5979     {
   5980         long double v = 1234567890.125;
   5981         std::ios ios(0);
   5982         // %g
   5983         {
   5984             ios.precision(0);
   5985             {
   5986                 nouppercase(ios);
   5987                 {
   5988                     noshowpos(ios);
   5989                     {
   5990                         noshowpoint(ios);
   5991                         {
   5992                             ios.imbue(lc);
   5993                             {
   5994                                 ios.width(0);
   5995                                 {
   5996                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5997                                     std::string ex(str, iter.base());
   5998                                     assert(ex == "1e+09");
   5999                                     assert(ios.width() == 0);
   6000                                 }
   6001                                 ios.width(25);
   6002                                 left(ios);
   6003                                 {
   6004                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6005                                     std::string ex(str, iter.base());
   6006                                     assert(ex == "1e+09********************");
   6007                                     assert(ios.width() == 0);
   6008                                 }
   6009                                 ios.width(25);
   6010                                 right(ios);
   6011                                 {
   6012                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6013                                     std::string ex(str, iter.base());
   6014                                     assert(ex == "********************1e+09");
   6015                                     assert(ios.width() == 0);
   6016                                 }
   6017                                 ios.width(25);
   6018                                 internal(ios);
   6019                                 {
   6020                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6021                                     std::string ex(str, iter.base());
   6022                                     assert(ex == "********************1e+09");
   6023                                     assert(ios.width() == 0);
   6024                                 }
   6025                             }
   6026                             ios.imbue(lg);
   6027                             {
   6028                                 ios.width(0);
   6029                                 {
   6030                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6031                                     std::string ex(str, iter.base());
   6032                                     assert(ex == "1e+09");
   6033                                     assert(ios.width() == 0);
   6034                                 }
   6035                                 ios.width(25);
   6036                                 left(ios);
   6037                                 {
   6038                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6039                                     std::string ex(str, iter.base());
   6040                                     assert(ex == "1e+09********************");
   6041                                     assert(ios.width() == 0);
   6042                                 }
   6043                                 ios.width(25);
   6044                                 right(ios);
   6045                                 {
   6046                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6047                                     std::string ex(str, iter.base());
   6048                                     assert(ex == "********************1e+09");
   6049                                     assert(ios.width() == 0);
   6050                                 }
   6051                                 ios.width(25);
   6052                                 internal(ios);
   6053                                 {
   6054                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6055                                     std::string ex(str, iter.base());
   6056                                     assert(ex == "********************1e+09");
   6057                                     assert(ios.width() == 0);
   6058                                 }
   6059                             }
   6060                         }
   6061                         showpoint(ios);
   6062                         {
   6063                             ios.imbue(lc);
   6064                             {
   6065                                 ios.width(0);
   6066                                 {
   6067                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6068                                     std::string ex(str, iter.base());
   6069                                     assert(ex == "1.e+09");
   6070                                     assert(ios.width() == 0);
   6071                                 }
   6072                                 ios.width(25);
   6073                                 left(ios);
   6074                                 {
   6075                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6076                                     std::string ex(str, iter.base());
   6077                                     assert(ex == "1.e+09*******************");
   6078                                     assert(ios.width() == 0);
   6079                                 }
   6080                                 ios.width(25);
   6081                                 right(ios);
   6082                                 {
   6083                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6084                                     std::string ex(str, iter.base());
   6085                                     assert(ex == "*******************1.e+09");
   6086                                     assert(ios.width() == 0);
   6087                                 }
   6088                                 ios.width(25);
   6089                                 internal(ios);
   6090                                 {
   6091                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6092                                     std::string ex(str, iter.base());
   6093                                     assert(ex == "*******************1.e+09");
   6094                                     assert(ios.width() == 0);
   6095                                 }
   6096                             }
   6097                             ios.imbue(lg);
   6098                             {
   6099                                 ios.width(0);
   6100                                 {
   6101                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6102                                     std::string ex(str, iter.base());
   6103                                     assert(ex == "1;e+09");
   6104                                     assert(ios.width() == 0);
   6105                                 }
   6106                                 ios.width(25);
   6107                                 left(ios);
   6108                                 {
   6109                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6110                                     std::string ex(str, iter.base());
   6111                                     assert(ex == "1;e+09*******************");
   6112                                     assert(ios.width() == 0);
   6113                                 }
   6114                                 ios.width(25);
   6115                                 right(ios);
   6116                                 {
   6117                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6118                                     std::string ex(str, iter.base());
   6119                                     assert(ex == "*******************1;e+09");
   6120                                     assert(ios.width() == 0);
   6121                                 }
   6122                                 ios.width(25);
   6123                                 internal(ios);
   6124                                 {
   6125                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6126                                     std::string ex(str, iter.base());
   6127                                     assert(ex == "*******************1;e+09");
   6128                                     assert(ios.width() == 0);
   6129                                 }
   6130                             }
   6131                         }
   6132                     }
   6133                     showpos(ios);
   6134                     {
   6135                         noshowpoint(ios);
   6136                         {
   6137                             ios.imbue(lc);
   6138                             {
   6139                                 ios.width(0);
   6140                                 {
   6141                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6142                                     std::string ex(str, iter.base());
   6143                                     assert(ex == "+1e+09");
   6144                                     assert(ios.width() == 0);
   6145                                 }
   6146                                 ios.width(25);
   6147                                 left(ios);
   6148                                 {
   6149                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6150                                     std::string ex(str, iter.base());
   6151                                     assert(ex == "+1e+09*******************");
   6152                                     assert(ios.width() == 0);
   6153                                 }
   6154                                 ios.width(25);
   6155                                 right(ios);
   6156                                 {
   6157                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6158                                     std::string ex(str, iter.base());
   6159                                     assert(ex == "*******************+1e+09");
   6160                                     assert(ios.width() == 0);
   6161                                 }
   6162                                 ios.width(25);
   6163                                 internal(ios);
   6164                                 {
   6165                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6166                                     std::string ex(str, iter.base());
   6167                                     assert(ex == "+*******************1e+09");
   6168                                     assert(ios.width() == 0);
   6169                                 }
   6170                             }
   6171                             ios.imbue(lg);
   6172                             {
   6173                                 ios.width(0);
   6174                                 {
   6175                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6176                                     std::string ex(str, iter.base());
   6177                                     assert(ex == "+1e+09");
   6178                                     assert(ios.width() == 0);
   6179                                 }
   6180                                 ios.width(25);
   6181                                 left(ios);
   6182                                 {
   6183                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6184                                     std::string ex(str, iter.base());
   6185                                     assert(ex == "+1e+09*******************");
   6186                                     assert(ios.width() == 0);
   6187                                 }
   6188                                 ios.width(25);
   6189                                 right(ios);
   6190                                 {
   6191                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6192                                     std::string ex(str, iter.base());
   6193                                     assert(ex == "*******************+1e+09");
   6194                                     assert(ios.width() == 0);
   6195                                 }
   6196                                 ios.width(25);
   6197                                 internal(ios);
   6198                                 {
   6199                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6200                                     std::string ex(str, iter.base());
   6201                                     assert(ex == "+*******************1e+09");
   6202                                     assert(ios.width() == 0);
   6203                                 }
   6204                             }
   6205                         }
   6206                         showpoint(ios);
   6207                         {
   6208                             ios.imbue(lc);
   6209                             {
   6210                                 ios.width(0);
   6211                                 {
   6212                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6213                                     std::string ex(str, iter.base());
   6214                                     assert(ex == "+1.e+09");
   6215                                     assert(ios.width() == 0);
   6216                                 }
   6217                                 ios.width(25);
   6218                                 left(ios);
   6219                                 {
   6220                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6221                                     std::string ex(str, iter.base());
   6222                                     assert(ex == "+1.e+09******************");
   6223                                     assert(ios.width() == 0);
   6224                                 }
   6225                                 ios.width(25);
   6226                                 right(ios);
   6227                                 {
   6228                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6229                                     std::string ex(str, iter.base());
   6230                                     assert(ex == "******************+1.e+09");
   6231                                     assert(ios.width() == 0);
   6232                                 }
   6233                                 ios.width(25);
   6234                                 internal(ios);
   6235                                 {
   6236                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6237                                     std::string ex(str, iter.base());
   6238                                     assert(ex == "+******************1.e+09");
   6239                                     assert(ios.width() == 0);
   6240                                 }
   6241                             }
   6242                             ios.imbue(lg);
   6243                             {
   6244                                 ios.width(0);
   6245                                 {
   6246                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6247                                     std::string ex(str, iter.base());
   6248                                     assert(ex == "+1;e+09");
   6249                                     assert(ios.width() == 0);
   6250                                 }
   6251                                 ios.width(25);
   6252                                 left(ios);
   6253                                 {
   6254                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6255                                     std::string ex(str, iter.base());
   6256                                     assert(ex == "+1;e+09******************");
   6257                                     assert(ios.width() == 0);
   6258                                 }
   6259                                 ios.width(25);
   6260                                 right(ios);
   6261                                 {
   6262                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6263                                     std::string ex(str, iter.base());
   6264                                     assert(ex == "******************+1;e+09");
   6265                                     assert(ios.width() == 0);
   6266                                 }
   6267                                 ios.width(25);
   6268                                 internal(ios);
   6269                                 {
   6270                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6271                                     std::string ex(str, iter.base());
   6272                                     assert(ex == "+******************1;e+09");
   6273                                     assert(ios.width() == 0);
   6274                                 }
   6275                             }
   6276                         }
   6277                     }
   6278                 }
   6279                 uppercase(ios);
   6280                 {
   6281                     noshowpos(ios);
   6282                     {
   6283                         noshowpoint(ios);
   6284                         {
   6285                             ios.imbue(lc);
   6286                             {
   6287                                 ios.width(0);
   6288                                 {
   6289                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6290                                     std::string ex(str, iter.base());
   6291                                     assert(ex == "1E+09");
   6292                                     assert(ios.width() == 0);
   6293                                 }
   6294                                 ios.width(25);
   6295                                 left(ios);
   6296                                 {
   6297                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6298                                     std::string ex(str, iter.base());
   6299                                     assert(ex == "1E+09********************");
   6300                                     assert(ios.width() == 0);
   6301                                 }
   6302                                 ios.width(25);
   6303                                 right(ios);
   6304                                 {
   6305                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6306                                     std::string ex(str, iter.base());
   6307                                     assert(ex == "********************1E+09");
   6308                                     assert(ios.width() == 0);
   6309                                 }
   6310                                 ios.width(25);
   6311                                 internal(ios);
   6312                                 {
   6313                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6314                                     std::string ex(str, iter.base());
   6315                                     assert(ex == "********************1E+09");
   6316                                     assert(ios.width() == 0);
   6317                                 }
   6318                             }
   6319                             ios.imbue(lg);
   6320                             {
   6321                                 ios.width(0);
   6322                                 {
   6323                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6324                                     std::string ex(str, iter.base());
   6325                                     assert(ex == "1E+09");
   6326                                     assert(ios.width() == 0);
   6327                                 }
   6328                                 ios.width(25);
   6329                                 left(ios);
   6330                                 {
   6331                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6332                                     std::string ex(str, iter.base());
   6333                                     assert(ex == "1E+09********************");
   6334                                     assert(ios.width() == 0);
   6335                                 }
   6336                                 ios.width(25);
   6337                                 right(ios);
   6338                                 {
   6339                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6340                                     std::string ex(str, iter.base());
   6341                                     assert(ex == "********************1E+09");
   6342                                     assert(ios.width() == 0);
   6343                                 }
   6344                                 ios.width(25);
   6345                                 internal(ios);
   6346                                 {
   6347                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6348                                     std::string ex(str, iter.base());
   6349                                     assert(ex == "********************1E+09");
   6350                                     assert(ios.width() == 0);
   6351                                 }
   6352                             }
   6353                         }
   6354                         showpoint(ios);
   6355                         {
   6356                             ios.imbue(lc);
   6357                             {
   6358                                 ios.width(0);
   6359                                 {
   6360                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6361                                     std::string ex(str, iter.base());
   6362                                     assert(ex == "1.E+09");
   6363                                     assert(ios.width() == 0);
   6364                                 }
   6365                                 ios.width(25);
   6366                                 left(ios);
   6367                                 {
   6368                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6369                                     std::string ex(str, iter.base());
   6370                                     assert(ex == "1.E+09*******************");
   6371                                     assert(ios.width() == 0);
   6372                                 }
   6373                                 ios.width(25);
   6374                                 right(ios);
   6375                                 {
   6376                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6377                                     std::string ex(str, iter.base());
   6378                                     assert(ex == "*******************1.E+09");
   6379                                     assert(ios.width() == 0);
   6380                                 }
   6381                                 ios.width(25);
   6382                                 internal(ios);
   6383                                 {
   6384                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6385                                     std::string ex(str, iter.base());
   6386                                     assert(ex == "*******************1.E+09");
   6387                                     assert(ios.width() == 0);
   6388                                 }
   6389                             }
   6390                             ios.imbue(lg);
   6391                             {
   6392                                 ios.width(0);
   6393                                 {
   6394                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6395                                     std::string ex(str, iter.base());
   6396                                     assert(ex == "1;E+09");
   6397                                     assert(ios.width() == 0);
   6398                                 }
   6399                                 ios.width(25);
   6400                                 left(ios);
   6401                                 {
   6402                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6403                                     std::string ex(str, iter.base());
   6404                                     assert(ex == "1;E+09*******************");
   6405                                     assert(ios.width() == 0);
   6406                                 }
   6407                                 ios.width(25);
   6408                                 right(ios);
   6409                                 {
   6410                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6411                                     std::string ex(str, iter.base());
   6412                                     assert(ex == "*******************1;E+09");
   6413                                     assert(ios.width() == 0);
   6414                                 }
   6415                                 ios.width(25);
   6416                                 internal(ios);
   6417                                 {
   6418                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6419                                     std::string ex(str, iter.base());
   6420                                     assert(ex == "*******************1;E+09");
   6421                                     assert(ios.width() == 0);
   6422                                 }
   6423                             }
   6424                         }
   6425                     }
   6426                     showpos(ios);
   6427                     {
   6428                         noshowpoint(ios);
   6429                         {
   6430                             ios.imbue(lc);
   6431                             {
   6432                                 ios.width(0);
   6433                                 {
   6434                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6435                                     std::string ex(str, iter.base());
   6436                                     assert(ex == "+1E+09");
   6437                                     assert(ios.width() == 0);
   6438                                 }
   6439                                 ios.width(25);
   6440                                 left(ios);
   6441                                 {
   6442                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6443                                     std::string ex(str, iter.base());
   6444                                     assert(ex == "+1E+09*******************");
   6445                                     assert(ios.width() == 0);
   6446                                 }
   6447                                 ios.width(25);
   6448                                 right(ios);
   6449                                 {
   6450                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6451                                     std::string ex(str, iter.base());
   6452                                     assert(ex == "*******************+1E+09");
   6453                                     assert(ios.width() == 0);
   6454                                 }
   6455                                 ios.width(25);
   6456                                 internal(ios);
   6457                                 {
   6458                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6459                                     std::string ex(str, iter.base());
   6460                                     assert(ex == "+*******************1E+09");
   6461                                     assert(ios.width() == 0);
   6462                                 }
   6463                             }
   6464                             ios.imbue(lg);
   6465                             {
   6466                                 ios.width(0);
   6467                                 {
   6468                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6469                                     std::string ex(str, iter.base());
   6470                                     assert(ex == "+1E+09");
   6471                                     assert(ios.width() == 0);
   6472                                 }
   6473                                 ios.width(25);
   6474                                 left(ios);
   6475                                 {
   6476                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6477                                     std::string ex(str, iter.base());
   6478                                     assert(ex == "+1E+09*******************");
   6479                                     assert(ios.width() == 0);
   6480                                 }
   6481                                 ios.width(25);
   6482                                 right(ios);
   6483                                 {
   6484                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6485                                     std::string ex(str, iter.base());
   6486                                     assert(ex == "*******************+1E+09");
   6487                                     assert(ios.width() == 0);
   6488                                 }
   6489                                 ios.width(25);
   6490                                 internal(ios);
   6491                                 {
   6492                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6493                                     std::string ex(str, iter.base());
   6494                                     assert(ex == "+*******************1E+09");
   6495                                     assert(ios.width() == 0);
   6496                                 }
   6497                             }
   6498                         }
   6499                         showpoint(ios);
   6500                         {
   6501                             ios.imbue(lc);
   6502                             {
   6503                                 ios.width(0);
   6504                                 {
   6505                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6506                                     std::string ex(str, iter.base());
   6507                                     assert(ex == "+1.E+09");
   6508                                     assert(ios.width() == 0);
   6509                                 }
   6510                                 ios.width(25);
   6511                                 left(ios);
   6512                                 {
   6513                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6514                                     std::string ex(str, iter.base());
   6515                                     assert(ex == "+1.E+09******************");
   6516                                     assert(ios.width() == 0);
   6517                                 }
   6518                                 ios.width(25);
   6519                                 right(ios);
   6520                                 {
   6521                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6522                                     std::string ex(str, iter.base());
   6523                                     assert(ex == "******************+1.E+09");
   6524                                     assert(ios.width() == 0);
   6525                                 }
   6526                                 ios.width(25);
   6527                                 internal(ios);
   6528                                 {
   6529                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6530                                     std::string ex(str, iter.base());
   6531                                     assert(ex == "+******************1.E+09");
   6532                                     assert(ios.width() == 0);
   6533                                 }
   6534                             }
   6535                             ios.imbue(lg);
   6536                             {
   6537                                 ios.width(0);
   6538                                 {
   6539                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6540                                     std::string ex(str, iter.base());
   6541                                     assert(ex == "+1;E+09");
   6542                                     assert(ios.width() == 0);
   6543                                 }
   6544                                 ios.width(25);
   6545                                 left(ios);
   6546                                 {
   6547                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6548                                     std::string ex(str, iter.base());
   6549                                     assert(ex == "+1;E+09******************");
   6550                                     assert(ios.width() == 0);
   6551                                 }
   6552                                 ios.width(25);
   6553                                 right(ios);
   6554                                 {
   6555                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6556                                     std::string ex(str, iter.base());
   6557                                     assert(ex == "******************+1;E+09");
   6558                                     assert(ios.width() == 0);
   6559                                 }
   6560                                 ios.width(25);
   6561                                 internal(ios);
   6562                                 {
   6563                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6564                                     std::string ex(str, iter.base());
   6565                                     assert(ex == "+******************1;E+09");
   6566                                     assert(ios.width() == 0);
   6567                                 }
   6568                             }
   6569                         }
   6570                     }
   6571                 }
   6572             }
   6573             ios.precision(1);
   6574             {
   6575                 nouppercase(ios);
   6576                 {
   6577                     noshowpos(ios);
   6578                     {
   6579                         noshowpoint(ios);
   6580                         {
   6581                             ios.imbue(lc);
   6582                             {
   6583                                 ios.width(0);
   6584                                 {
   6585                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6586                                     std::string ex(str, iter.base());
   6587                                     assert(ex == "1e+09");
   6588                                     assert(ios.width() == 0);
   6589                                 }
   6590                                 ios.width(25);
   6591                                 left(ios);
   6592                                 {
   6593                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6594                                     std::string ex(str, iter.base());
   6595                                     assert(ex == "1e+09********************");
   6596                                     assert(ios.width() == 0);
   6597                                 }
   6598                                 ios.width(25);
   6599                                 right(ios);
   6600                                 {
   6601                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6602                                     std::string ex(str, iter.base());
   6603                                     assert(ex == "********************1e+09");
   6604                                     assert(ios.width() == 0);
   6605                                 }
   6606                                 ios.width(25);
   6607                                 internal(ios);
   6608                                 {
   6609                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6610                                     std::string ex(str, iter.base());
   6611                                     assert(ex == "********************1e+09");
   6612                                     assert(ios.width() == 0);
   6613                                 }
   6614                             }
   6615                             ios.imbue(lg);
   6616                             {
   6617                                 ios.width(0);
   6618                                 {
   6619                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6620                                     std::string ex(str, iter.base());
   6621                                     assert(ex == "1e+09");
   6622                                     assert(ios.width() == 0);
   6623                                 }
   6624                                 ios.width(25);
   6625                                 left(ios);
   6626                                 {
   6627                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6628                                     std::string ex(str, iter.base());
   6629                                     assert(ex == "1e+09********************");
   6630                                     assert(ios.width() == 0);
   6631                                 }
   6632                                 ios.width(25);
   6633                                 right(ios);
   6634                                 {
   6635                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6636                                     std::string ex(str, iter.base());
   6637                                     assert(ex == "********************1e+09");
   6638                                     assert(ios.width() == 0);
   6639                                 }
   6640                                 ios.width(25);
   6641                                 internal(ios);
   6642                                 {
   6643                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6644                                     std::string ex(str, iter.base());
   6645                                     assert(ex == "********************1e+09");
   6646                                     assert(ios.width() == 0);
   6647                                 }
   6648                             }
   6649                         }
   6650                         showpoint(ios);
   6651                         {
   6652                             ios.imbue(lc);
   6653                             {
   6654                                 ios.width(0);
   6655                                 {
   6656                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6657                                     std::string ex(str, iter.base());
   6658                                     assert(ex == "1.e+09");
   6659                                     assert(ios.width() == 0);
   6660                                 }
   6661                                 ios.width(25);
   6662                                 left(ios);
   6663                                 {
   6664                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6665                                     std::string ex(str, iter.base());
   6666                                     assert(ex == "1.e+09*******************");
   6667                                     assert(ios.width() == 0);
   6668                                 }
   6669                                 ios.width(25);
   6670                                 right(ios);
   6671                                 {
   6672                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6673                                     std::string ex(str, iter.base());
   6674                                     assert(ex == "*******************1.e+09");
   6675                                     assert(ios.width() == 0);
   6676                                 }
   6677                                 ios.width(25);
   6678                                 internal(ios);
   6679                                 {
   6680                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6681                                     std::string ex(str, iter.base());
   6682                                     assert(ex == "*******************1.e+09");
   6683                                     assert(ios.width() == 0);
   6684                                 }
   6685                             }
   6686                             ios.imbue(lg);
   6687                             {
   6688                                 ios.width(0);
   6689                                 {
   6690                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6691                                     std::string ex(str, iter.base());
   6692                                     assert(ex == "1;e+09");
   6693                                     assert(ios.width() == 0);
   6694                                 }
   6695                                 ios.width(25);
   6696                                 left(ios);
   6697                                 {
   6698                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6699                                     std::string ex(str, iter.base());
   6700                                     assert(ex == "1;e+09*******************");
   6701                                     assert(ios.width() == 0);
   6702                                 }
   6703                                 ios.width(25);
   6704                                 right(ios);
   6705                                 {
   6706                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6707                                     std::string ex(str, iter.base());
   6708                                     assert(ex == "*******************1;e+09");
   6709                                     assert(ios.width() == 0);
   6710                                 }
   6711                                 ios.width(25);
   6712                                 internal(ios);
   6713                                 {
   6714                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6715                                     std::string ex(str, iter.base());
   6716                                     assert(ex == "*******************1;e+09");
   6717                                     assert(ios.width() == 0);
   6718                                 }
   6719                             }
   6720                         }
   6721                     }
   6722                     showpos(ios);
   6723                     {
   6724                         noshowpoint(ios);
   6725                         {
   6726                             ios.imbue(lc);
   6727                             {
   6728                                 ios.width(0);
   6729                                 {
   6730                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6731                                     std::string ex(str, iter.base());
   6732                                     assert(ex == "+1e+09");
   6733                                     assert(ios.width() == 0);
   6734                                 }
   6735                                 ios.width(25);
   6736                                 left(ios);
   6737                                 {
   6738                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6739                                     std::string ex(str, iter.base());
   6740                                     assert(ex == "+1e+09*******************");
   6741                                     assert(ios.width() == 0);
   6742                                 }
   6743                                 ios.width(25);
   6744                                 right(ios);
   6745                                 {
   6746                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6747                                     std::string ex(str, iter.base());
   6748                                     assert(ex == "*******************+1e+09");
   6749                                     assert(ios.width() == 0);
   6750                                 }
   6751                                 ios.width(25);
   6752                                 internal(ios);
   6753                                 {
   6754                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6755                                     std::string ex(str, iter.base());
   6756                                     assert(ex == "+*******************1e+09");
   6757                                     assert(ios.width() == 0);
   6758                                 }
   6759                             }
   6760                             ios.imbue(lg);
   6761                             {
   6762                                 ios.width(0);
   6763                                 {
   6764                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6765                                     std::string ex(str, iter.base());
   6766                                     assert(ex == "+1e+09");
   6767                                     assert(ios.width() == 0);
   6768                                 }
   6769                                 ios.width(25);
   6770                                 left(ios);
   6771                                 {
   6772                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6773                                     std::string ex(str, iter.base());
   6774                                     assert(ex == "+1e+09*******************");
   6775                                     assert(ios.width() == 0);
   6776                                 }
   6777                                 ios.width(25);
   6778                                 right(ios);
   6779                                 {
   6780                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6781                                     std::string ex(str, iter.base());
   6782                                     assert(ex == "*******************+1e+09");
   6783                                     assert(ios.width() == 0);
   6784                                 }
   6785                                 ios.width(25);
   6786                                 internal(ios);
   6787                                 {
   6788                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6789                                     std::string ex(str, iter.base());
   6790                                     assert(ex == "+*******************1e+09");
   6791                                     assert(ios.width() == 0);
   6792                                 }
   6793                             }
   6794                         }
   6795                         showpoint(ios);
   6796                         {
   6797                             ios.imbue(lc);
   6798                             {
   6799                                 ios.width(0);
   6800                                 {
   6801                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6802                                     std::string ex(str, iter.base());
   6803                                     assert(ex == "+1.e+09");
   6804                                     assert(ios.width() == 0);
   6805                                 }
   6806                                 ios.width(25);
   6807                                 left(ios);
   6808                                 {
   6809                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6810                                     std::string ex(str, iter.base());
   6811                                     assert(ex == "+1.e+09******************");
   6812                                     assert(ios.width() == 0);
   6813                                 }
   6814                                 ios.width(25);
   6815                                 right(ios);
   6816                                 {
   6817                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6818                                     std::string ex(str, iter.base());
   6819                                     assert(ex == "******************+1.e+09");
   6820                                     assert(ios.width() == 0);
   6821                                 }
   6822                                 ios.width(25);
   6823                                 internal(ios);
   6824                                 {
   6825                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6826                                     std::string ex(str, iter.base());
   6827                                     assert(ex == "+******************1.e+09");
   6828                                     assert(ios.width() == 0);
   6829                                 }
   6830                             }
   6831                             ios.imbue(lg);
   6832                             {
   6833                                 ios.width(0);
   6834                                 {
   6835                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6836                                     std::string ex(str, iter.base());
   6837                                     assert(ex == "+1;e+09");
   6838                                     assert(ios.width() == 0);
   6839                                 }
   6840                                 ios.width(25);
   6841                                 left(ios);
   6842                                 {
   6843                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6844                                     std::string ex(str, iter.base());
   6845                                     assert(ex == "+1;e+09******************");
   6846                                     assert(ios.width() == 0);
   6847                                 }
   6848                                 ios.width(25);
   6849                                 right(ios);
   6850                                 {
   6851                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6852                                     std::string ex(str, iter.base());
   6853                                     assert(ex == "******************+1;e+09");
   6854                                     assert(ios.width() == 0);
   6855                                 }
   6856                                 ios.width(25);
   6857                                 internal(ios);
   6858                                 {
   6859                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6860                                     std::string ex(str, iter.base());
   6861                                     assert(ex == "+******************1;e+09");
   6862                                     assert(ios.width() == 0);
   6863                                 }
   6864                             }
   6865                         }
   6866                     }
   6867                 }
   6868                 uppercase(ios);
   6869                 {
   6870                     noshowpos(ios);
   6871                     {
   6872                         noshowpoint(ios);
   6873                         {
   6874                             ios.imbue(lc);
   6875                             {
   6876                                 ios.width(0);
   6877                                 {
   6878                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6879                                     std::string ex(str, iter.base());
   6880                                     assert(ex == "1E+09");
   6881                                     assert(ios.width() == 0);
   6882                                 }
   6883                                 ios.width(25);
   6884                                 left(ios);
   6885                                 {
   6886                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6887                                     std::string ex(str, iter.base());
   6888                                     assert(ex == "1E+09********************");
   6889                                     assert(ios.width() == 0);
   6890                                 }
   6891                                 ios.width(25);
   6892                                 right(ios);
   6893                                 {
   6894                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6895                                     std::string ex(str, iter.base());
   6896                                     assert(ex == "********************1E+09");
   6897                                     assert(ios.width() == 0);
   6898                                 }
   6899                                 ios.width(25);
   6900                                 internal(ios);
   6901                                 {
   6902                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6903                                     std::string ex(str, iter.base());
   6904                                     assert(ex == "********************1E+09");
   6905                                     assert(ios.width() == 0);
   6906                                 }
   6907                             }
   6908                             ios.imbue(lg);
   6909                             {
   6910                                 ios.width(0);
   6911                                 {
   6912                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6913                                     std::string ex(str, iter.base());
   6914                                     assert(ex == "1E+09");
   6915                                     assert(ios.width() == 0);
   6916                                 }
   6917                                 ios.width(25);
   6918                                 left(ios);
   6919                                 {
   6920                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6921                                     std::string ex(str, iter.base());
   6922                                     assert(ex == "1E+09********************");
   6923                                     assert(ios.width() == 0);
   6924                                 }
   6925                                 ios.width(25);
   6926                                 right(ios);
   6927                                 {
   6928                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6929                                     std::string ex(str, iter.base());
   6930                                     assert(ex == "********************1E+09");
   6931                                     assert(ios.width() == 0);
   6932                                 }
   6933                                 ios.width(25);
   6934                                 internal(ios);
   6935                                 {
   6936                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6937                                     std::string ex(str, iter.base());
   6938                                     assert(ex == "********************1E+09");
   6939                                     assert(ios.width() == 0);
   6940                                 }
   6941                             }
   6942                         }
   6943                         showpoint(ios);
   6944                         {
   6945                             ios.imbue(lc);
   6946                             {
   6947                                 ios.width(0);
   6948                                 {
   6949                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6950                                     std::string ex(str, iter.base());
   6951                                     assert(ex == "1.E+09");
   6952                                     assert(ios.width() == 0);
   6953                                 }
   6954                                 ios.width(25);
   6955                                 left(ios);
   6956                                 {
   6957                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6958                                     std::string ex(str, iter.base());
   6959                                     assert(ex == "1.E+09*******************");
   6960                                     assert(ios.width() == 0);
   6961                                 }
   6962                                 ios.width(25);
   6963                                 right(ios);
   6964                                 {
   6965                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6966                                     std::string ex(str, iter.base());
   6967                                     assert(ex == "*******************1.E+09");
   6968                                     assert(ios.width() == 0);
   6969                                 }
   6970                                 ios.width(25);
   6971                                 internal(ios);
   6972                                 {
   6973                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6974                                     std::string ex(str, iter.base());
   6975                                     assert(ex == "*******************1.E+09");
   6976                                     assert(ios.width() == 0);
   6977                                 }
   6978                             }
   6979                             ios.imbue(lg);
   6980                             {
   6981                                 ios.width(0);
   6982                                 {
   6983                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6984                                     std::string ex(str, iter.base());
   6985                                     assert(ex == "1;E+09");
   6986                                     assert(ios.width() == 0);
   6987                                 }
   6988                                 ios.width(25);
   6989                                 left(ios);
   6990                                 {
   6991                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6992                                     std::string ex(str, iter.base());
   6993                                     assert(ex == "1;E+09*******************");
   6994                                     assert(ios.width() == 0);
   6995                                 }
   6996                                 ios.width(25);
   6997                                 right(ios);
   6998                                 {
   6999                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7000                                     std::string ex(str, iter.base());
   7001                                     assert(ex == "*******************1;E+09");
   7002                                     assert(ios.width() == 0);
   7003                                 }
   7004                                 ios.width(25);
   7005                                 internal(ios);
   7006                                 {
   7007                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7008                                     std::string ex(str, iter.base());
   7009                                     assert(ex == "*******************1;E+09");
   7010                                     assert(ios.width() == 0);
   7011                                 }
   7012                             }
   7013                         }
   7014                     }
   7015                     showpos(ios);
   7016                     {
   7017                         noshowpoint(ios);
   7018                         {
   7019                             ios.imbue(lc);
   7020                             {
   7021                                 ios.width(0);
   7022                                 {
   7023                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7024                                     std::string ex(str, iter.base());
   7025                                     assert(ex == "+1E+09");
   7026                                     assert(ios.width() == 0);
   7027                                 }
   7028                                 ios.width(25);
   7029                                 left(ios);
   7030                                 {
   7031                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7032                                     std::string ex(str, iter.base());
   7033                                     assert(ex == "+1E+09*******************");
   7034                                     assert(ios.width() == 0);
   7035                                 }
   7036                                 ios.width(25);
   7037                                 right(ios);
   7038                                 {
   7039                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7040                                     std::string ex(str, iter.base());
   7041                                     assert(ex == "*******************+1E+09");
   7042                                     assert(ios.width() == 0);
   7043                                 }
   7044                                 ios.width(25);
   7045                                 internal(ios);
   7046                                 {
   7047                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7048                                     std::string ex(str, iter.base());
   7049                                     assert(ex == "+*******************1E+09");
   7050                                     assert(ios.width() == 0);
   7051                                 }
   7052                             }
   7053                             ios.imbue(lg);
   7054                             {
   7055                                 ios.width(0);
   7056                                 {
   7057                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7058                                     std::string ex(str, iter.base());
   7059                                     assert(ex == "+1E+09");
   7060                                     assert(ios.width() == 0);
   7061                                 }
   7062                                 ios.width(25);
   7063                                 left(ios);
   7064                                 {
   7065                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7066                                     std::string ex(str, iter.base());
   7067                                     assert(ex == "+1E+09*******************");
   7068                                     assert(ios.width() == 0);
   7069                                 }
   7070                                 ios.width(25);
   7071                                 right(ios);
   7072                                 {
   7073                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7074                                     std::string ex(str, iter.base());
   7075                                     assert(ex == "*******************+1E+09");
   7076                                     assert(ios.width() == 0);
   7077                                 }
   7078                                 ios.width(25);
   7079                                 internal(ios);
   7080                                 {
   7081                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7082                                     std::string ex(str, iter.base());
   7083                                     assert(ex == "+*******************1E+09");
   7084                                     assert(ios.width() == 0);
   7085                                 }
   7086                             }
   7087                         }
   7088                         showpoint(ios);
   7089                         {
   7090                             ios.imbue(lc);
   7091                             {
   7092                                 ios.width(0);
   7093                                 {
   7094                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7095                                     std::string ex(str, iter.base());
   7096                                     assert(ex == "+1.E+09");
   7097                                     assert(ios.width() == 0);
   7098                                 }
   7099                                 ios.width(25);
   7100                                 left(ios);
   7101                                 {
   7102                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7103                                     std::string ex(str, iter.base());
   7104                                     assert(ex == "+1.E+09******************");
   7105                                     assert(ios.width() == 0);
   7106                                 }
   7107                                 ios.width(25);
   7108                                 right(ios);
   7109                                 {
   7110                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7111                                     std::string ex(str, iter.base());
   7112                                     assert(ex == "******************+1.E+09");
   7113                                     assert(ios.width() == 0);
   7114                                 }
   7115                                 ios.width(25);
   7116                                 internal(ios);
   7117                                 {
   7118                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7119                                     std::string ex(str, iter.base());
   7120                                     assert(ex == "+******************1.E+09");
   7121                                     assert(ios.width() == 0);
   7122                                 }
   7123                             }
   7124                             ios.imbue(lg);
   7125                             {
   7126                                 ios.width(0);
   7127                                 {
   7128                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7129                                     std::string ex(str, iter.base());
   7130                                     assert(ex == "+1;E+09");
   7131                                     assert(ios.width() == 0);
   7132                                 }
   7133                                 ios.width(25);
   7134                                 left(ios);
   7135                                 {
   7136                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7137                                     std::string ex(str, iter.base());
   7138                                     assert(ex == "+1;E+09******************");
   7139                                     assert(ios.width() == 0);
   7140                                 }
   7141                                 ios.width(25);
   7142                                 right(ios);
   7143                                 {
   7144                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7145                                     std::string ex(str, iter.base());
   7146                                     assert(ex == "******************+1;E+09");
   7147                                     assert(ios.width() == 0);
   7148                                 }
   7149                                 ios.width(25);
   7150                                 internal(ios);
   7151                                 {
   7152                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7153                                     std::string ex(str, iter.base());
   7154                                     assert(ex == "+******************1;E+09");
   7155                                     assert(ios.width() == 0);
   7156                                 }
   7157                             }
   7158                         }
   7159                     }
   7160                 }
   7161             }
   7162             ios.precision(6);
   7163             {
   7164                 nouppercase(ios);
   7165                 {
   7166                     noshowpos(ios);
   7167                     {
   7168                         noshowpoint(ios);
   7169                         {
   7170                             ios.imbue(lc);
   7171                             {
   7172                                 ios.width(0);
   7173                                 {
   7174                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7175                                     std::string ex(str, iter.base());
   7176                                     assert(ex == "1.23457e+09");
   7177                                     assert(ios.width() == 0);
   7178                                 }
   7179                                 ios.width(25);
   7180                                 left(ios);
   7181                                 {
   7182                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7183                                     std::string ex(str, iter.base());
   7184                                     assert(ex == "1.23457e+09**************");
   7185                                     assert(ios.width() == 0);
   7186                                 }
   7187                                 ios.width(25);
   7188                                 right(ios);
   7189                                 {
   7190                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7191                                     std::string ex(str, iter.base());
   7192                                     assert(ex == "**************1.23457e+09");
   7193                                     assert(ios.width() == 0);
   7194                                 }
   7195                                 ios.width(25);
   7196                                 internal(ios);
   7197                                 {
   7198                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7199                                     std::string ex(str, iter.base());
   7200                                     assert(ex == "**************1.23457e+09");
   7201                                     assert(ios.width() == 0);
   7202                                 }
   7203                             }
   7204                             ios.imbue(lg);
   7205                             {
   7206                                 ios.width(0);
   7207                                 {
   7208                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7209                                     std::string ex(str, iter.base());
   7210                                     assert(ex == "1;23457e+09");
   7211                                     assert(ios.width() == 0);
   7212                                 }
   7213                                 ios.width(25);
   7214                                 left(ios);
   7215                                 {
   7216                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7217                                     std::string ex(str, iter.base());
   7218                                     assert(ex == "1;23457e+09**************");
   7219                                     assert(ios.width() == 0);
   7220                                 }
   7221                                 ios.width(25);
   7222                                 right(ios);
   7223                                 {
   7224                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7225                                     std::string ex(str, iter.base());
   7226                                     assert(ex == "**************1;23457e+09");
   7227                                     assert(ios.width() == 0);
   7228                                 }
   7229                                 ios.width(25);
   7230                                 internal(ios);
   7231                                 {
   7232                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7233                                     std::string ex(str, iter.base());
   7234                                     assert(ex == "**************1;23457e+09");
   7235                                     assert(ios.width() == 0);
   7236                                 }
   7237                             }
   7238                         }
   7239                         showpoint(ios);
   7240                         {
   7241                             ios.imbue(lc);
   7242                             {
   7243                                 ios.width(0);
   7244                                 {
   7245                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7246                                     std::string ex(str, iter.base());
   7247                                     assert(ex == "1.23457e+09");
   7248                                     assert(ios.width() == 0);
   7249                                 }
   7250                                 ios.width(25);
   7251                                 left(ios);
   7252                                 {
   7253                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7254                                     std::string ex(str, iter.base());
   7255                                     assert(ex == "1.23457e+09**************");
   7256                                     assert(ios.width() == 0);
   7257                                 }
   7258                                 ios.width(25);
   7259                                 right(ios);
   7260                                 {
   7261                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7262                                     std::string ex(str, iter.base());
   7263                                     assert(ex == "**************1.23457e+09");
   7264                                     assert(ios.width() == 0);
   7265                                 }
   7266                                 ios.width(25);
   7267                                 internal(ios);
   7268                                 {
   7269                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7270                                     std::string ex(str, iter.base());
   7271                                     assert(ex == "**************1.23457e+09");
   7272                                     assert(ios.width() == 0);
   7273                                 }
   7274                             }
   7275                             ios.imbue(lg);
   7276                             {
   7277                                 ios.width(0);
   7278                                 {
   7279                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7280                                     std::string ex(str, iter.base());
   7281                                     assert(ex == "1;23457e+09");
   7282                                     assert(ios.width() == 0);
   7283                                 }
   7284                                 ios.width(25);
   7285                                 left(ios);
   7286                                 {
   7287                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7288                                     std::string ex(str, iter.base());
   7289                                     assert(ex == "1;23457e+09**************");
   7290                                     assert(ios.width() == 0);
   7291                                 }
   7292                                 ios.width(25);
   7293                                 right(ios);
   7294                                 {
   7295                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7296                                     std::string ex(str, iter.base());
   7297                                     assert(ex == "**************1;23457e+09");
   7298                                     assert(ios.width() == 0);
   7299                                 }
   7300                                 ios.width(25);
   7301                                 internal(ios);
   7302                                 {
   7303                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7304                                     std::string ex(str, iter.base());
   7305                                     assert(ex == "**************1;23457e+09");
   7306                                     assert(ios.width() == 0);
   7307                                 }
   7308                             }
   7309                         }
   7310                     }
   7311                     showpos(ios);
   7312                     {
   7313                         noshowpoint(ios);
   7314                         {
   7315                             ios.imbue(lc);
   7316                             {
   7317                                 ios.width(0);
   7318                                 {
   7319                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7320                                     std::string ex(str, iter.base());
   7321                                     assert(ex == "+1.23457e+09");
   7322                                     assert(ios.width() == 0);
   7323                                 }
   7324                                 ios.width(25);
   7325                                 left(ios);
   7326                                 {
   7327                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7328                                     std::string ex(str, iter.base());
   7329                                     assert(ex == "+1.23457e+09*************");
   7330                                     assert(ios.width() == 0);
   7331                                 }
   7332                                 ios.width(25);
   7333                                 right(ios);
   7334                                 {
   7335                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7336                                     std::string ex(str, iter.base());
   7337                                     assert(ex == "*************+1.23457e+09");
   7338                                     assert(ios.width() == 0);
   7339                                 }
   7340                                 ios.width(25);
   7341                                 internal(ios);
   7342                                 {
   7343                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7344                                     std::string ex(str, iter.base());
   7345                                     assert(ex == "+*************1.23457e+09");
   7346                                     assert(ios.width() == 0);
   7347                                 }
   7348                             }
   7349                             ios.imbue(lg);
   7350                             {
   7351                                 ios.width(0);
   7352                                 {
   7353                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7354                                     std::string ex(str, iter.base());
   7355                                     assert(ex == "+1;23457e+09");
   7356                                     assert(ios.width() == 0);
   7357                                 }
   7358                                 ios.width(25);
   7359                                 left(ios);
   7360                                 {
   7361                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7362                                     std::string ex(str, iter.base());
   7363                                     assert(ex == "+1;23457e+09*************");
   7364                                     assert(ios.width() == 0);
   7365                                 }
   7366                                 ios.width(25);
   7367                                 right(ios);
   7368                                 {
   7369                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7370                                     std::string ex(str, iter.base());
   7371                                     assert(ex == "*************+1;23457e+09");
   7372                                     assert(ios.width() == 0);
   7373                                 }
   7374                                 ios.width(25);
   7375                                 internal(ios);
   7376                                 {
   7377                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7378                                     std::string ex(str, iter.base());
   7379                                     assert(ex == "+*************1;23457e+09");
   7380                                     assert(ios.width() == 0);
   7381                                 }
   7382                             }
   7383                         }
   7384                         showpoint(ios);
   7385                         {
   7386                             ios.imbue(lc);
   7387                             {
   7388                                 ios.width(0);
   7389                                 {
   7390                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7391                                     std::string ex(str, iter.base());
   7392                                     assert(ex == "+1.23457e+09");
   7393                                     assert(ios.width() == 0);
   7394                                 }
   7395                                 ios.width(25);
   7396                                 left(ios);
   7397                                 {
   7398                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7399                                     std::string ex(str, iter.base());
   7400                                     assert(ex == "+1.23457e+09*************");
   7401                                     assert(ios.width() == 0);
   7402                                 }
   7403                                 ios.width(25);
   7404                                 right(ios);
   7405                                 {
   7406                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7407                                     std::string ex(str, iter.base());
   7408                                     assert(ex == "*************+1.23457e+09");
   7409                                     assert(ios.width() == 0);
   7410                                 }
   7411                                 ios.width(25);
   7412                                 internal(ios);
   7413                                 {
   7414                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7415                                     std::string ex(str, iter.base());
   7416                                     assert(ex == "+*************1.23457e+09");
   7417                                     assert(ios.width() == 0);
   7418                                 }
   7419                             }
   7420                             ios.imbue(lg);
   7421                             {
   7422                                 ios.width(0);
   7423                                 {
   7424                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7425                                     std::string ex(str, iter.base());
   7426                                     assert(ex == "+1;23457e+09");
   7427                                     assert(ios.width() == 0);
   7428                                 }
   7429                                 ios.width(25);
   7430                                 left(ios);
   7431                                 {
   7432                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7433                                     std::string ex(str, iter.base());
   7434                                     assert(ex == "+1;23457e+09*************");
   7435                                     assert(ios.width() == 0);
   7436                                 }
   7437                                 ios.width(25);
   7438                                 right(ios);
   7439                                 {
   7440                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7441                                     std::string ex(str, iter.base());
   7442                                     assert(ex == "*************+1;23457e+09");
   7443                                     assert(ios.width() == 0);
   7444                                 }
   7445                                 ios.width(25);
   7446                                 internal(ios);
   7447                                 {
   7448                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7449                                     std::string ex(str, iter.base());
   7450                                     assert(ex == "+*************1;23457e+09");
   7451                                     assert(ios.width() == 0);
   7452                                 }
   7453                             }
   7454                         }
   7455                     }
   7456                 }
   7457                 uppercase(ios);
   7458                 {
   7459                     noshowpos(ios);
   7460                     {
   7461                         noshowpoint(ios);
   7462                         {
   7463                             ios.imbue(lc);
   7464                             {
   7465                                 ios.width(0);
   7466                                 {
   7467                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7468                                     std::string ex(str, iter.base());
   7469                                     assert(ex == "1.23457E+09");
   7470                                     assert(ios.width() == 0);
   7471                                 }
   7472                                 ios.width(25);
   7473                                 left(ios);
   7474                                 {
   7475                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7476                                     std::string ex(str, iter.base());
   7477                                     assert(ex == "1.23457E+09**************");
   7478                                     assert(ios.width() == 0);
   7479                                 }
   7480                                 ios.width(25);
   7481                                 right(ios);
   7482                                 {
   7483                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7484                                     std::string ex(str, iter.base());
   7485                                     assert(ex == "**************1.23457E+09");
   7486                                     assert(ios.width() == 0);
   7487                                 }
   7488                                 ios.width(25);
   7489                                 internal(ios);
   7490                                 {
   7491                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7492                                     std::string ex(str, iter.base());
   7493                                     assert(ex == "**************1.23457E+09");
   7494                                     assert(ios.width() == 0);
   7495                                 }
   7496                             }
   7497                             ios.imbue(lg);
   7498                             {
   7499                                 ios.width(0);
   7500                                 {
   7501                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7502                                     std::string ex(str, iter.base());
   7503                                     assert(ex == "1;23457E+09");
   7504                                     assert(ios.width() == 0);
   7505                                 }
   7506                                 ios.width(25);
   7507                                 left(ios);
   7508                                 {
   7509                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7510                                     std::string ex(str, iter.base());
   7511                                     assert(ex == "1;23457E+09**************");
   7512                                     assert(ios.width() == 0);
   7513                                 }
   7514                                 ios.width(25);
   7515                                 right(ios);
   7516                                 {
   7517                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7518                                     std::string ex(str, iter.base());
   7519                                     assert(ex == "**************1;23457E+09");
   7520                                     assert(ios.width() == 0);
   7521                                 }
   7522                                 ios.width(25);
   7523                                 internal(ios);
   7524                                 {
   7525                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7526                                     std::string ex(str, iter.base());
   7527                                     assert(ex == "**************1;23457E+09");
   7528                                     assert(ios.width() == 0);
   7529                                 }
   7530                             }
   7531                         }
   7532                         showpoint(ios);
   7533                         {
   7534                             ios.imbue(lc);
   7535                             {
   7536                                 ios.width(0);
   7537                                 {
   7538                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7539                                     std::string ex(str, iter.base());
   7540                                     assert(ex == "1.23457E+09");
   7541                                     assert(ios.width() == 0);
   7542                                 }
   7543                                 ios.width(25);
   7544                                 left(ios);
   7545                                 {
   7546                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7547                                     std::string ex(str, iter.base());
   7548                                     assert(ex == "1.23457E+09**************");
   7549                                     assert(ios.width() == 0);
   7550                                 }
   7551                                 ios.width(25);
   7552                                 right(ios);
   7553                                 {
   7554                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7555                                     std::string ex(str, iter.base());
   7556                                     assert(ex == "**************1.23457E+09");
   7557                                     assert(ios.width() == 0);
   7558                                 }
   7559                                 ios.width(25);
   7560                                 internal(ios);
   7561                                 {
   7562                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7563                                     std::string ex(str, iter.base());
   7564                                     assert(ex == "**************1.23457E+09");
   7565                                     assert(ios.width() == 0);
   7566                                 }
   7567                             }
   7568                             ios.imbue(lg);
   7569                             {
   7570                                 ios.width(0);
   7571                                 {
   7572                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7573                                     std::string ex(str, iter.base());
   7574                                     assert(ex == "1;23457E+09");
   7575                                     assert(ios.width() == 0);
   7576                                 }
   7577                                 ios.width(25);
   7578                                 left(ios);
   7579                                 {
   7580                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7581                                     std::string ex(str, iter.base());
   7582                                     assert(ex == "1;23457E+09**************");
   7583                                     assert(ios.width() == 0);
   7584                                 }
   7585                                 ios.width(25);
   7586                                 right(ios);
   7587                                 {
   7588                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7589                                     std::string ex(str, iter.base());
   7590                                     assert(ex == "**************1;23457E+09");
   7591                                     assert(ios.width() == 0);
   7592                                 }
   7593                                 ios.width(25);
   7594                                 internal(ios);
   7595                                 {
   7596                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7597                                     std::string ex(str, iter.base());
   7598                                     assert(ex == "**************1;23457E+09");
   7599                                     assert(ios.width() == 0);
   7600                                 }
   7601                             }
   7602                         }
   7603                     }
   7604                     showpos(ios);
   7605                     {
   7606                         noshowpoint(ios);
   7607                         {
   7608                             ios.imbue(lc);
   7609                             {
   7610                                 ios.width(0);
   7611                                 {
   7612                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7613                                     std::string ex(str, iter.base());
   7614                                     assert(ex == "+1.23457E+09");
   7615                                     assert(ios.width() == 0);
   7616                                 }
   7617                                 ios.width(25);
   7618                                 left(ios);
   7619                                 {
   7620                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7621                                     std::string ex(str, iter.base());
   7622                                     assert(ex == "+1.23457E+09*************");
   7623                                     assert(ios.width() == 0);
   7624                                 }
   7625                                 ios.width(25);
   7626                                 right(ios);
   7627                                 {
   7628                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7629                                     std::string ex(str, iter.base());
   7630                                     assert(ex == "*************+1.23457E+09");
   7631                                     assert(ios.width() == 0);
   7632                                 }
   7633                                 ios.width(25);
   7634                                 internal(ios);
   7635                                 {
   7636                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7637                                     std::string ex(str, iter.base());
   7638                                     assert(ex == "+*************1.23457E+09");
   7639                                     assert(ios.width() == 0);
   7640                                 }
   7641                             }
   7642                             ios.imbue(lg);
   7643                             {
   7644                                 ios.width(0);
   7645                                 {
   7646                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7647                                     std::string ex(str, iter.base());
   7648                                     assert(ex == "+1;23457E+09");
   7649                                     assert(ios.width() == 0);
   7650                                 }
   7651                                 ios.width(25);
   7652                                 left(ios);
   7653                                 {
   7654                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7655                                     std::string ex(str, iter.base());
   7656                                     assert(ex == "+1;23457E+09*************");
   7657                                     assert(ios.width() == 0);
   7658                                 }
   7659                                 ios.width(25);
   7660                                 right(ios);
   7661                                 {
   7662                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7663                                     std::string ex(str, iter.base());
   7664                                     assert(ex == "*************+1;23457E+09");
   7665                                     assert(ios.width() == 0);
   7666                                 }
   7667                                 ios.width(25);
   7668                                 internal(ios);
   7669                                 {
   7670                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7671                                     std::string ex(str, iter.base());
   7672                                     assert(ex == "+*************1;23457E+09");
   7673                                     assert(ios.width() == 0);
   7674                                 }
   7675                             }
   7676                         }
   7677                         showpoint(ios);
   7678                         {
   7679                             ios.imbue(lc);
   7680                             {
   7681                                 ios.width(0);
   7682                                 {
   7683                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7684                                     std::string ex(str, iter.base());
   7685                                     assert(ex == "+1.23457E+09");
   7686                                     assert(ios.width() == 0);
   7687                                 }
   7688                                 ios.width(25);
   7689                                 left(ios);
   7690                                 {
   7691                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7692                                     std::string ex(str, iter.base());
   7693                                     assert(ex == "+1.23457E+09*************");
   7694                                     assert(ios.width() == 0);
   7695                                 }
   7696                                 ios.width(25);
   7697                                 right(ios);
   7698                                 {
   7699                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7700                                     std::string ex(str, iter.base());
   7701                                     assert(ex == "*************+1.23457E+09");
   7702                                     assert(ios.width() == 0);
   7703                                 }
   7704                                 ios.width(25);
   7705                                 internal(ios);
   7706                                 {
   7707                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7708                                     std::string ex(str, iter.base());
   7709                                     assert(ex == "+*************1.23457E+09");
   7710                                     assert(ios.width() == 0);
   7711                                 }
   7712                             }
   7713                             ios.imbue(lg);
   7714                             {
   7715                                 ios.width(0);
   7716                                 {
   7717                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7718                                     std::string ex(str, iter.base());
   7719                                     assert(ex == "+1;23457E+09");
   7720                                     assert(ios.width() == 0);
   7721                                 }
   7722                                 ios.width(25);
   7723                                 left(ios);
   7724                                 {
   7725                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7726                                     std::string ex(str, iter.base());
   7727                                     assert(ex == "+1;23457E+09*************");
   7728                                     assert(ios.width() == 0);
   7729                                 }
   7730                                 ios.width(25);
   7731                                 right(ios);
   7732                                 {
   7733                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7734                                     std::string ex(str, iter.base());
   7735                                     assert(ex == "*************+1;23457E+09");
   7736                                     assert(ios.width() == 0);
   7737                                 }
   7738                                 ios.width(25);
   7739                                 internal(ios);
   7740                                 {
   7741                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7742                                     std::string ex(str, iter.base());
   7743                                     assert(ex == "+*************1;23457E+09");
   7744                                     assert(ios.width() == 0);
   7745                                 }
   7746                             }
   7747                         }
   7748                     }
   7749                 }
   7750             }
   7751             ios.precision(16);
   7752             {
   7753                 nouppercase(ios);
   7754                 {
   7755                     noshowpos(ios);
   7756                     {
   7757                         noshowpoint(ios);
   7758                         {
   7759                             ios.imbue(lc);
   7760                             {
   7761                                 ios.width(0);
   7762                                 {
   7763                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7764                                     std::string ex(str, iter.base());
   7765                                     assert(ex == "1234567890.125");
   7766                                     assert(ios.width() == 0);
   7767                                 }
   7768                                 ios.width(25);
   7769                                 left(ios);
   7770                                 {
   7771                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7772                                     std::string ex(str, iter.base());
   7773                                     assert(ex == "1234567890.125***********");
   7774                                     assert(ios.width() == 0);
   7775                                 }
   7776                                 ios.width(25);
   7777                                 right(ios);
   7778                                 {
   7779                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7780                                     std::string ex(str, iter.base());
   7781                                     assert(ex == "***********1234567890.125");
   7782                                     assert(ios.width() == 0);
   7783                                 }
   7784                                 ios.width(25);
   7785                                 internal(ios);
   7786                                 {
   7787                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7788                                     std::string ex(str, iter.base());
   7789                                     assert(ex == "***********1234567890.125");
   7790                                     assert(ios.width() == 0);
   7791                                 }
   7792                             }
   7793                             ios.imbue(lg);
   7794                             {
   7795                                 ios.width(0);
   7796                                 {
   7797                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7798                                     std::string ex(str, iter.base());
   7799                                     assert(ex == "1_234_567_89_0;125");
   7800                                     assert(ios.width() == 0);
   7801                                 }
   7802                                 ios.width(25);
   7803                                 left(ios);
   7804                                 {
   7805                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7806                                     std::string ex(str, iter.base());
   7807                                     assert(ex == "1_234_567_89_0;125*******");
   7808                                     assert(ios.width() == 0);
   7809                                 }
   7810                                 ios.width(25);
   7811                                 right(ios);
   7812                                 {
   7813                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7814                                     std::string ex(str, iter.base());
   7815                                     assert(ex == "*******1_234_567_89_0;125");
   7816                                     assert(ios.width() == 0);
   7817                                 }
   7818                                 ios.width(25);
   7819                                 internal(ios);
   7820                                 {
   7821                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7822                                     std::string ex(str, iter.base());
   7823                                     assert(ex == "*******1_234_567_89_0;125");
   7824                                     assert(ios.width() == 0);
   7825                                 }
   7826                             }
   7827                         }
   7828                         showpoint(ios);
   7829                         {
   7830                             ios.imbue(lc);
   7831                             {
   7832                                 ios.width(0);
   7833                                 {
   7834                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7835                                     std::string ex(str, iter.base());
   7836                                     assert(ex == "1234567890.125000");
   7837                                     assert(ios.width() == 0);
   7838                                 }
   7839                                 ios.width(25);
   7840                                 left(ios);
   7841                                 {
   7842                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7843                                     std::string ex(str, iter.base());
   7844                                     assert(ex == "1234567890.125000********");
   7845                                     assert(ios.width() == 0);
   7846                                 }
   7847                                 ios.width(25);
   7848                                 right(ios);
   7849                                 {
   7850                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7851                                     std::string ex(str, iter.base());
   7852                                     assert(ex == "********1234567890.125000");
   7853                                     assert(ios.width() == 0);
   7854                                 }
   7855                                 ios.width(25);
   7856                                 internal(ios);
   7857                                 {
   7858                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7859                                     std::string ex(str, iter.base());
   7860                                     assert(ex == "********1234567890.125000");
   7861                                     assert(ios.width() == 0);
   7862                                 }
   7863                             }
   7864                             ios.imbue(lg);
   7865                             {
   7866                                 ios.width(0);
   7867                                 {
   7868                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7869                                     std::string ex(str, iter.base());
   7870                                     assert(ex == "1_234_567_89_0;125000");
   7871                                     assert(ios.width() == 0);
   7872                                 }
   7873                                 ios.width(25);
   7874                                 left(ios);
   7875                                 {
   7876                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7877                                     std::string ex(str, iter.base());
   7878                                     assert(ex == "1_234_567_89_0;125000****");
   7879                                     assert(ios.width() == 0);
   7880                                 }
   7881                                 ios.width(25);
   7882                                 right(ios);
   7883                                 {
   7884                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7885                                     std::string ex(str, iter.base());
   7886                                     assert(ex == "****1_234_567_89_0;125000");
   7887                                     assert(ios.width() == 0);
   7888                                 }
   7889                                 ios.width(25);
   7890                                 internal(ios);
   7891                                 {
   7892                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7893                                     std::string ex(str, iter.base());
   7894                                     assert(ex == "****1_234_567_89_0;125000");
   7895                                     assert(ios.width() == 0);
   7896                                 }
   7897                             }
   7898                         }
   7899                     }
   7900                     showpos(ios);
   7901                     {
   7902                         noshowpoint(ios);
   7903                         {
   7904                             ios.imbue(lc);
   7905                             {
   7906                                 ios.width(0);
   7907                                 {
   7908                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7909                                     std::string ex(str, iter.base());
   7910                                     assert(ex == "+1234567890.125");
   7911                                     assert(ios.width() == 0);
   7912                                 }
   7913                                 ios.width(25);
   7914                                 left(ios);
   7915                                 {
   7916                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7917                                     std::string ex(str, iter.base());
   7918                                     assert(ex == "+1234567890.125**********");
   7919                                     assert(ios.width() == 0);
   7920                                 }
   7921                                 ios.width(25);
   7922                                 right(ios);
   7923                                 {
   7924                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7925                                     std::string ex(str, iter.base());
   7926                                     assert(ex == "**********+1234567890.125");
   7927                                     assert(ios.width() == 0);
   7928                                 }
   7929                                 ios.width(25);
   7930                                 internal(ios);
   7931                                 {
   7932                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7933                                     std::string ex(str, iter.base());
   7934                                     assert(ex == "+**********1234567890.125");
   7935                                     assert(ios.width() == 0);
   7936                                 }
   7937                             }
   7938                             ios.imbue(lg);
   7939                             {
   7940                                 ios.width(0);
   7941                                 {
   7942                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7943                                     std::string ex(str, iter.base());
   7944                                     assert(ex == "+1_234_567_89_0;125");
   7945                                     assert(ios.width() == 0);
   7946                                 }
   7947                                 ios.width(25);
   7948                                 left(ios);
   7949                                 {
   7950                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7951                                     std::string ex(str, iter.base());
   7952                                     assert(ex == "+1_234_567_89_0;125******");
   7953                                     assert(ios.width() == 0);
   7954                                 }
   7955                                 ios.width(25);
   7956                                 right(ios);
   7957                                 {
   7958                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7959                                     std::string ex(str, iter.base());
   7960                                     assert(ex == "******+1_234_567_89_0;125");
   7961                                     assert(ios.width() == 0);
   7962                                 }
   7963                                 ios.width(25);
   7964                                 internal(ios);
   7965                                 {
   7966                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7967                                     std::string ex(str, iter.base());
   7968                                     assert(ex == "+******1_234_567_89_0;125");
   7969                                     assert(ios.width() == 0);
   7970                                 }
   7971                             }
   7972                         }
   7973                         showpoint(ios);
   7974                         {
   7975                             ios.imbue(lc);
   7976                             {
   7977                                 ios.width(0);
   7978                                 {
   7979                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7980                                     std::string ex(str, iter.base());
   7981                                     assert(ex == "+1234567890.125000");
   7982                                     assert(ios.width() == 0);
   7983                                 }
   7984                                 ios.width(25);
   7985                                 left(ios);
   7986                                 {
   7987                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7988                                     std::string ex(str, iter.base());
   7989                                     assert(ex == "+1234567890.125000*******");
   7990                                     assert(ios.width() == 0);
   7991                                 }
   7992                                 ios.width(25);
   7993                                 right(ios);
   7994                                 {
   7995                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7996                                     std::string ex(str, iter.base());
   7997                                     assert(ex == "*******+1234567890.125000");
   7998                                     assert(ios.width() == 0);
   7999                                 }
   8000                                 ios.width(25);
   8001                                 internal(ios);
   8002                                 {
   8003                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8004                                     std::string ex(str, iter.base());
   8005                                     assert(ex == "+*******1234567890.125000");
   8006                                     assert(ios.width() == 0);
   8007                                 }
   8008                             }
   8009                             ios.imbue(lg);
   8010                             {
   8011                                 ios.width(0);
   8012                                 {
   8013                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8014                                     std::string ex(str, iter.base());
   8015                                     assert(ex == "+1_234_567_89_0;125000");
   8016                                     assert(ios.width() == 0);
   8017                                 }
   8018                                 ios.width(25);
   8019                                 left(ios);
   8020                                 {
   8021                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8022                                     std::string ex(str, iter.base());
   8023                                     assert(ex == "+1_234_567_89_0;125000***");
   8024                                     assert(ios.width() == 0);
   8025                                 }
   8026                                 ios.width(25);
   8027                                 right(ios);
   8028                                 {
   8029                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8030                                     std::string ex(str, iter.base());
   8031                                     assert(ex == "***+1_234_567_89_0;125000");
   8032                                     assert(ios.width() == 0);
   8033                                 }
   8034                                 ios.width(25);
   8035                                 internal(ios);
   8036                                 {
   8037                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8038                                     std::string ex(str, iter.base());
   8039                                     assert(ex == "+***1_234_567_89_0;125000");
   8040                                     assert(ios.width() == 0);
   8041                                 }
   8042                             }
   8043                         }
   8044                     }
   8045                 }
   8046                 uppercase(ios);
   8047                 {
   8048                     noshowpos(ios);
   8049                     {
   8050                         noshowpoint(ios);
   8051                         {
   8052                             ios.imbue(lc);
   8053                             {
   8054                                 ios.width(0);
   8055                                 {
   8056                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8057                                     std::string ex(str, iter.base());
   8058                                     assert(ex == "1234567890.125");
   8059                                     assert(ios.width() == 0);
   8060                                 }
   8061                                 ios.width(25);
   8062                                 left(ios);
   8063                                 {
   8064                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8065                                     std::string ex(str, iter.base());
   8066                                     assert(ex == "1234567890.125***********");
   8067                                     assert(ios.width() == 0);
   8068                                 }
   8069                                 ios.width(25);
   8070                                 right(ios);
   8071                                 {
   8072                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8073                                     std::string ex(str, iter.base());
   8074                                     assert(ex == "***********1234567890.125");
   8075                                     assert(ios.width() == 0);
   8076                                 }
   8077                                 ios.width(25);
   8078                                 internal(ios);
   8079                                 {
   8080                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8081                                     std::string ex(str, iter.base());
   8082                                     assert(ex == "***********1234567890.125");
   8083                                     assert(ios.width() == 0);
   8084                                 }
   8085                             }
   8086                             ios.imbue(lg);
   8087                             {
   8088                                 ios.width(0);
   8089                                 {
   8090                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8091                                     std::string ex(str, iter.base());
   8092                                     assert(ex == "1_234_567_89_0;125");
   8093                                     assert(ios.width() == 0);
   8094                                 }
   8095                                 ios.width(25);
   8096                                 left(ios);
   8097                                 {
   8098                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8099                                     std::string ex(str, iter.base());
   8100                                     assert(ex == "1_234_567_89_0;125*******");
   8101                                     assert(ios.width() == 0);
   8102                                 }
   8103                                 ios.width(25);
   8104                                 right(ios);
   8105                                 {
   8106                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8107                                     std::string ex(str, iter.base());
   8108                                     assert(ex == "*******1_234_567_89_0;125");
   8109                                     assert(ios.width() == 0);
   8110                                 }
   8111                                 ios.width(25);
   8112                                 internal(ios);
   8113                                 {
   8114                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8115                                     std::string ex(str, iter.base());
   8116                                     assert(ex == "*******1_234_567_89_0;125");
   8117                                     assert(ios.width() == 0);
   8118                                 }
   8119                             }
   8120                         }
   8121                         showpoint(ios);
   8122                         {
   8123                             ios.imbue(lc);
   8124                             {
   8125                                 ios.width(0);
   8126                                 {
   8127                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8128                                     std::string ex(str, iter.base());
   8129                                     assert(ex == "1234567890.125000");
   8130                                     assert(ios.width() == 0);
   8131                                 }
   8132                                 ios.width(25);
   8133                                 left(ios);
   8134                                 {
   8135                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8136                                     std::string ex(str, iter.base());
   8137                                     assert(ex == "1234567890.125000********");
   8138                                     assert(ios.width() == 0);
   8139                                 }
   8140                                 ios.width(25);
   8141                                 right(ios);
   8142                                 {
   8143                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8144                                     std::string ex(str, iter.base());
   8145                                     assert(ex == "********1234567890.125000");
   8146                                     assert(ios.width() == 0);
   8147                                 }
   8148                                 ios.width(25);
   8149                                 internal(ios);
   8150                                 {
   8151                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8152                                     std::string ex(str, iter.base());
   8153                                     assert(ex == "********1234567890.125000");
   8154                                     assert(ios.width() == 0);
   8155                                 }
   8156                             }
   8157                             ios.imbue(lg);
   8158                             {
   8159                                 ios.width(0);
   8160                                 {
   8161                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8162                                     std::string ex(str, iter.base());
   8163                                     assert(ex == "1_234_567_89_0;125000");
   8164                                     assert(ios.width() == 0);
   8165                                 }
   8166                                 ios.width(25);
   8167                                 left(ios);
   8168                                 {
   8169                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8170                                     std::string ex(str, iter.base());
   8171                                     assert(ex == "1_234_567_89_0;125000****");
   8172                                     assert(ios.width() == 0);
   8173                                 }
   8174                                 ios.width(25);
   8175                                 right(ios);
   8176                                 {
   8177                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8178                                     std::string ex(str, iter.base());
   8179                                     assert(ex == "****1_234_567_89_0;125000");
   8180                                     assert(ios.width() == 0);
   8181                                 }
   8182                                 ios.width(25);
   8183                                 internal(ios);
   8184                                 {
   8185                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8186                                     std::string ex(str, iter.base());
   8187                                     assert(ex == "****1_234_567_89_0;125000");
   8188                                     assert(ios.width() == 0);
   8189                                 }
   8190                             }
   8191                         }
   8192                     }
   8193                     showpos(ios);
   8194                     {
   8195                         noshowpoint(ios);
   8196                         {
   8197                             ios.imbue(lc);
   8198                             {
   8199                                 ios.width(0);
   8200                                 {
   8201                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8202                                     std::string ex(str, iter.base());
   8203                                     assert(ex == "+1234567890.125");
   8204                                     assert(ios.width() == 0);
   8205                                 }
   8206                                 ios.width(25);
   8207                                 left(ios);
   8208                                 {
   8209                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8210                                     std::string ex(str, iter.base());
   8211                                     assert(ex == "+1234567890.125**********");
   8212                                     assert(ios.width() == 0);
   8213                                 }
   8214                                 ios.width(25);
   8215                                 right(ios);
   8216                                 {
   8217                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8218                                     std::string ex(str, iter.base());
   8219                                     assert(ex == "**********+1234567890.125");
   8220                                     assert(ios.width() == 0);
   8221                                 }
   8222                                 ios.width(25);
   8223                                 internal(ios);
   8224                                 {
   8225                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8226                                     std::string ex(str, iter.base());
   8227                                     assert(ex == "+**********1234567890.125");
   8228                                     assert(ios.width() == 0);
   8229                                 }
   8230                             }
   8231                             ios.imbue(lg);
   8232                             {
   8233                                 ios.width(0);
   8234                                 {
   8235                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8236                                     std::string ex(str, iter.base());
   8237                                     assert(ex == "+1_234_567_89_0;125");
   8238                                     assert(ios.width() == 0);
   8239                                 }
   8240                                 ios.width(25);
   8241                                 left(ios);
   8242                                 {
   8243                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8244                                     std::string ex(str, iter.base());
   8245                                     assert(ex == "+1_234_567_89_0;125******");
   8246                                     assert(ios.width() == 0);
   8247                                 }
   8248                                 ios.width(25);
   8249                                 right(ios);
   8250                                 {
   8251                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8252                                     std::string ex(str, iter.base());
   8253                                     assert(ex == "******+1_234_567_89_0;125");
   8254                                     assert(ios.width() == 0);
   8255                                 }
   8256                                 ios.width(25);
   8257                                 internal(ios);
   8258                                 {
   8259                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8260                                     std::string ex(str, iter.base());
   8261                                     assert(ex == "+******1_234_567_89_0;125");
   8262                                     assert(ios.width() == 0);
   8263                                 }
   8264                             }
   8265                         }
   8266                         showpoint(ios);
   8267                         {
   8268                             ios.imbue(lc);
   8269                             {
   8270                                 ios.width(0);
   8271                                 {
   8272                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8273                                     std::string ex(str, iter.base());
   8274                                     assert(ex == "+1234567890.125000");
   8275                                     assert(ios.width() == 0);
   8276                                 }
   8277                                 ios.width(25);
   8278                                 left(ios);
   8279                                 {
   8280                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8281                                     std::string ex(str, iter.base());
   8282                                     assert(ex == "+1234567890.125000*******");
   8283                                     assert(ios.width() == 0);
   8284                                 }
   8285                                 ios.width(25);
   8286                                 right(ios);
   8287                                 {
   8288                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8289                                     std::string ex(str, iter.base());
   8290                                     assert(ex == "*******+1234567890.125000");
   8291                                     assert(ios.width() == 0);
   8292                                 }
   8293                                 ios.width(25);
   8294                                 internal(ios);
   8295                                 {
   8296                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8297                                     std::string ex(str, iter.base());
   8298                                     assert(ex == "+*******1234567890.125000");
   8299                                     assert(ios.width() == 0);
   8300                                 }
   8301                             }
   8302                             ios.imbue(lg);
   8303                             {
   8304                                 ios.width(0);
   8305                                 {
   8306                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8307                                     std::string ex(str, iter.base());
   8308                                     assert(ex == "+1_234_567_89_0;125000");
   8309                                     assert(ios.width() == 0);
   8310                                 }
   8311                                 ios.width(25);
   8312                                 left(ios);
   8313                                 {
   8314                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8315                                     std::string ex(str, iter.base());
   8316                                     assert(ex == "+1_234_567_89_0;125000***");
   8317                                     assert(ios.width() == 0);
   8318                                 }
   8319                                 ios.width(25);
   8320                                 right(ios);
   8321                                 {
   8322                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8323                                     std::string ex(str, iter.base());
   8324                                     assert(ex == "***+1_234_567_89_0;125000");
   8325                                     assert(ios.width() == 0);
   8326                                 }
   8327                                 ios.width(25);
   8328                                 internal(ios);
   8329                                 {
   8330                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8331                                     std::string ex(str, iter.base());
   8332                                     assert(ex == "+***1_234_567_89_0;125000");
   8333                                     assert(ios.width() == 0);
   8334                                 }
   8335                             }
   8336                         }
   8337                     }
   8338                 }
   8339             }
   8340             ios.precision(60);
   8341             {
   8342                 nouppercase(ios);
   8343                 {
   8344                     noshowpos(ios);
   8345                     {
   8346                         noshowpoint(ios);
   8347                         {
   8348                             ios.imbue(lc);
   8349                             {
   8350                                 ios.width(0);
   8351                                 {
   8352                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8353                                     std::string ex(str, iter.base());
   8354                                     assert(ex == "1234567890.125");
   8355                                     assert(ios.width() == 0);
   8356                                 }
   8357                                 ios.width(25);
   8358                                 left(ios);
   8359                                 {
   8360                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8361                                     std::string ex(str, iter.base());
   8362                                     assert(ex == "1234567890.125***********");
   8363                                     assert(ios.width() == 0);
   8364                                 }
   8365                                 ios.width(25);
   8366                                 right(ios);
   8367                                 {
   8368                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8369                                     std::string ex(str, iter.base());
   8370                                     assert(ex == "***********1234567890.125");
   8371                                     assert(ios.width() == 0);
   8372                                 }
   8373                                 ios.width(25);
   8374                                 internal(ios);
   8375                                 {
   8376                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8377                                     std::string ex(str, iter.base());
   8378                                     assert(ex == "***********1234567890.125");
   8379                                     assert(ios.width() == 0);
   8380                                 }
   8381                             }
   8382                             ios.imbue(lg);
   8383                             {
   8384                                 ios.width(0);
   8385                                 {
   8386                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8387                                     std::string ex(str, iter.base());
   8388                                     assert(ex == "1_234_567_89_0;125");
   8389                                     assert(ios.width() == 0);
   8390                                 }
   8391                                 ios.width(25);
   8392                                 left(ios);
   8393                                 {
   8394                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8395                                     std::string ex(str, iter.base());
   8396                                     assert(ex == "1_234_567_89_0;125*******");
   8397                                     assert(ios.width() == 0);
   8398                                 }
   8399                                 ios.width(25);
   8400                                 right(ios);
   8401                                 {
   8402                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8403                                     std::string ex(str, iter.base());
   8404                                     assert(ex == "*******1_234_567_89_0;125");
   8405                                     assert(ios.width() == 0);
   8406                                 }
   8407                                 ios.width(25);
   8408                                 internal(ios);
   8409                                 {
   8410                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8411                                     std::string ex(str, iter.base());
   8412                                     assert(ex == "*******1_234_567_89_0;125");
   8413                                     assert(ios.width() == 0);
   8414                                 }
   8415                             }
   8416                         }
   8417                         showpoint(ios);
   8418                         {
   8419                             ios.imbue(lc);
   8420                             {
   8421                                 ios.width(0);
   8422                                 {
   8423                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8424                                     std::string ex(str, iter.base());
   8425                                     assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
   8426                                     assert(ios.width() == 0);
   8427                                 }
   8428                                 ios.width(25);
   8429                                 left(ios);
   8430                                 {
   8431                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8432                                     std::string ex(str, iter.base());
   8433                                     assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
   8434                                     assert(ios.width() == 0);
   8435                                 }
   8436                                 ios.width(25);
   8437                                 right(ios);
   8438                                 {
   8439                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8440                                     std::string ex(str, iter.base());
   8441                                     assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
   8442                                     assert(ios.width() == 0);
   8443                                 }
   8444                                 ios.width(25);
   8445                                 internal(ios);
   8446                                 {
   8447                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8448                                     std::string ex(str, iter.base());
   8449                                     assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
   8450                                     assert(ios.width() == 0);
   8451                                 }
   8452                             }
   8453                             ios.imbue(lg);
   8454                             {
   8455                                 ios.width(0);
   8456                                 {
   8457                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8458                                     std::string ex(str, iter.base());
   8459                                     assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8460                                     assert(ios.width() == 0);
   8461                                 }
   8462                                 ios.width(25);
   8463                                 left(ios);
   8464                                 {
   8465                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8466                                     std::string ex(str, iter.base());
   8467                                     assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8468                                     assert(ios.width() == 0);
   8469                                 }
   8470                                 ios.width(25);
   8471                                 right(ios);
   8472                                 {
   8473                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8474                                     std::string ex(str, iter.base());
   8475                                     assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8476                                     assert(ios.width() == 0);
   8477                                 }
   8478                                 ios.width(25);
   8479                                 internal(ios);
   8480                                 {
   8481                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8482                                     std::string ex(str, iter.base());
   8483                                     assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8484                                     assert(ios.width() == 0);
   8485                                 }
   8486                             }
   8487                         }
   8488                     }
   8489                     showpos(ios);
   8490                     {
   8491                         noshowpoint(ios);
   8492                         {
   8493                             ios.imbue(lc);
   8494                             {
   8495                                 ios.width(0);
   8496                                 {
   8497                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8498                                     std::string ex(str, iter.base());
   8499                                     assert(ex == "+1234567890.125");
   8500                                     assert(ios.width() == 0);
   8501                                 }
   8502                                 ios.width(25);
   8503                                 left(ios);
   8504                                 {
   8505                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8506                                     std::string ex(str, iter.base());
   8507                                     assert(ex == "+1234567890.125**********");
   8508                                     assert(ios.width() == 0);
   8509                                 }
   8510                                 ios.width(25);
   8511                                 right(ios);
   8512                                 {
   8513                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8514                                     std::string ex(str, iter.base());
   8515                                     assert(ex == "**********+1234567890.125");
   8516                                     assert(ios.width() == 0);
   8517                                 }
   8518                                 ios.width(25);
   8519                                 internal(ios);
   8520                                 {
   8521                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8522                                     std::string ex(str, iter.base());
   8523                                     assert(ex == "+**********1234567890.125");
   8524                                     assert(ios.width() == 0);
   8525                                 }
   8526                             }
   8527                             ios.imbue(lg);
   8528                             {
   8529                                 ios.width(0);
   8530                                 {
   8531                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8532                                     std::string ex(str, iter.base());
   8533                                     assert(ex == "+1_234_567_89_0;125");
   8534                                     assert(ios.width() == 0);
   8535                                 }
   8536                                 ios.width(25);
   8537                                 left(ios);
   8538                                 {
   8539                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8540                                     std::string ex(str, iter.base());
   8541                                     assert(ex == "+1_234_567_89_0;125******");
   8542                                     assert(ios.width() == 0);
   8543                                 }
   8544                                 ios.width(25);
   8545                                 right(ios);
   8546                                 {
   8547                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8548                                     std::string ex(str, iter.base());
   8549                                     assert(ex == "******+1_234_567_89_0;125");
   8550                                     assert(ios.width() == 0);
   8551                                 }
   8552                                 ios.width(25);
   8553                                 internal(ios);
   8554                                 {
   8555                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8556                                     std::string ex(str, iter.base());
   8557                                     assert(ex == "+******1_234_567_89_0;125");
   8558                                     assert(ios.width() == 0);
   8559                                 }
   8560                             }
   8561                         }
   8562                         showpoint(ios);
   8563                         {
   8564                             ios.imbue(lc);
   8565                             {
   8566                                 ios.width(0);
   8567                                 {
   8568                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8569                                     std::string ex(str, iter.base());
   8570                                     assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
   8571                                     assert(ios.width() == 0);
   8572                                 }
   8573                                 ios.width(25);
   8574                                 left(ios);
   8575                                 {
   8576                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8577                                     std::string ex(str, iter.base());
   8578                                     assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
   8579                                     assert(ios.width() == 0);
   8580                                 }
   8581                                 ios.width(25);
   8582                                 right(ios);
   8583                                 {
   8584                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8585                                     std::string ex(str, iter.base());
   8586                                     assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
   8587                                     assert(ios.width() == 0);
   8588                                 }
   8589                                 ios.width(25);
   8590                                 internal(ios);
   8591                                 {
   8592                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8593                                     std::string ex(str, iter.base());
   8594                                     assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
   8595                                     assert(ios.width() == 0);
   8596                                 }
   8597                             }
   8598                             ios.imbue(lg);
   8599                             {
   8600                                 ios.width(0);
   8601                                 {
   8602                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8603                                     std::string ex(str, iter.base());
   8604                                     assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8605                                     assert(ios.width() == 0);
   8606                                 }
   8607                                 ios.width(25);
   8608                                 left(ios);
   8609                                 {
   8610                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8611                                     std::string ex(str, iter.base());
   8612                                     assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8613                                     assert(ios.width() == 0);
   8614                                 }
   8615                                 ios.width(25);
   8616                                 right(ios);
   8617                                 {
   8618                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8619                                     std::string ex(str, iter.base());
   8620                                     assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8621                                     assert(ios.width() == 0);
   8622                                 }
   8623                                 ios.width(25);
   8624                                 internal(ios);
   8625                                 {
   8626                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8627                                     std::string ex(str, iter.base());
   8628                                     assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8629                                     assert(ios.width() == 0);
   8630                                 }
   8631                             }
   8632                         }
   8633                     }
   8634                 }
   8635                 uppercase(ios);
   8636                 {
   8637                     noshowpos(ios);
   8638                     {
   8639                         noshowpoint(ios);
   8640                         {
   8641                             ios.imbue(lc);
   8642                             {
   8643                                 ios.width(0);
   8644                                 {
   8645                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8646                                     std::string ex(str, iter.base());
   8647                                     assert(ex == "1234567890.125");
   8648                                     assert(ios.width() == 0);
   8649                                 }
   8650                                 ios.width(25);
   8651                                 left(ios);
   8652                                 {
   8653                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8654                                     std::string ex(str, iter.base());
   8655                                     assert(ex == "1234567890.125***********");
   8656                                     assert(ios.width() == 0);
   8657                                 }
   8658                                 ios.width(25);
   8659                                 right(ios);
   8660                                 {
   8661                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8662                                     std::string ex(str, iter.base());
   8663                                     assert(ex == "***********1234567890.125");
   8664                                     assert(ios.width() == 0);
   8665                                 }
   8666                                 ios.width(25);
   8667                                 internal(ios);
   8668                                 {
   8669                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8670                                     std::string ex(str, iter.base());
   8671                                     assert(ex == "***********1234567890.125");
   8672                                     assert(ios.width() == 0);
   8673                                 }
   8674                             }
   8675                             ios.imbue(lg);
   8676                             {
   8677                                 ios.width(0);
   8678                                 {
   8679                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8680                                     std::string ex(str, iter.base());
   8681                                     assert(ex == "1_234_567_89_0;125");
   8682                                     assert(ios.width() == 0);
   8683                                 }
   8684                                 ios.width(25);
   8685                                 left(ios);
   8686                                 {
   8687                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8688                                     std::string ex(str, iter.base());
   8689                                     assert(ex == "1_234_567_89_0;125*******");
   8690                                     assert(ios.width() == 0);
   8691                                 }
   8692                                 ios.width(25);
   8693                                 right(ios);
   8694                                 {
   8695                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8696                                     std::string ex(str, iter.base());
   8697                                     assert(ex == "*******1_234_567_89_0;125");
   8698                                     assert(ios.width() == 0);
   8699                                 }
   8700                                 ios.width(25);
   8701                                 internal(ios);
   8702                                 {
   8703                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8704                                     std::string ex(str, iter.base());
   8705                                     assert(ex == "*******1_234_567_89_0;125");
   8706                                     assert(ios.width() == 0);
   8707                                 }
   8708                             }
   8709                         }
   8710                         showpoint(ios);
   8711                         {
   8712                             ios.imbue(lc);
   8713                             {
   8714                                 ios.width(0);
   8715                                 {
   8716                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8717                                     std::string ex(str, iter.base());
   8718                                     assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
   8719                                     assert(ios.width() == 0);
   8720                                 }
   8721                                 ios.width(25);
   8722                                 left(ios);
   8723                                 {
   8724                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8725                                     std::string ex(str, iter.base());
   8726                                     assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
   8727                                     assert(ios.width() == 0);
   8728                                 }
   8729                                 ios.width(25);
   8730                                 right(ios);
   8731                                 {
   8732                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8733                                     std::string ex(str, iter.base());
   8734                                     assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
   8735                                     assert(ios.width() == 0);
   8736                                 }
   8737                                 ios.width(25);
   8738                                 internal(ios);
   8739                                 {
   8740                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8741                                     std::string ex(str, iter.base());
   8742                                     assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
   8743                                     assert(ios.width() == 0);
   8744                                 }
   8745                             }
   8746                             ios.imbue(lg);
   8747                             {
   8748                                 ios.width(0);
   8749                                 {
   8750                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8751                                     std::string ex(str, iter.base());
   8752                                     assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8753                                     assert(ios.width() == 0);
   8754                                 }
   8755                                 ios.width(25);
   8756                                 left(ios);
   8757                                 {
   8758                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8759                                     std::string ex(str, iter.base());
   8760                                     assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8761                                     assert(ios.width() == 0);
   8762                                 }
   8763                                 ios.width(25);
   8764                                 right(ios);
   8765                                 {
   8766                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8767                                     std::string ex(str, iter.base());
   8768                                     assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8769                                     assert(ios.width() == 0);
   8770                                 }
   8771                                 ios.width(25);
   8772                                 internal(ios);
   8773                                 {
   8774                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8775                                     std::string ex(str, iter.base());
   8776                                     assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8777                                     assert(ios.width() == 0);
   8778                                 }
   8779                             }
   8780                         }
   8781                     }
   8782                     showpos(ios);
   8783                     {
   8784                         noshowpoint(ios);
   8785                         {
   8786                             ios.imbue(lc);
   8787                             {
   8788                                 ios.width(0);
   8789                                 {
   8790                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8791                                     std::string ex(str, iter.base());
   8792                                     assert(ex == "+1234567890.125");
   8793                                     assert(ios.width() == 0);
   8794                                 }
   8795                                 ios.width(25);
   8796                                 left(ios);
   8797                                 {
   8798                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8799                                     std::string ex(str, iter.base());
   8800                                     assert(ex == "+1234567890.125**********");
   8801                                     assert(ios.width() == 0);
   8802                                 }
   8803                                 ios.width(25);
   8804                                 right(ios);
   8805                                 {
   8806                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8807                                     std::string ex(str, iter.base());
   8808                                     assert(ex == "**********+1234567890.125");
   8809                                     assert(ios.width() == 0);
   8810                                 }
   8811                                 ios.width(25);
   8812                                 internal(ios);
   8813                                 {
   8814                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8815                                     std::string ex(str, iter.base());
   8816                                     assert(ex == "+**********1234567890.125");
   8817                                     assert(ios.width() == 0);
   8818                                 }
   8819                             }
   8820                             ios.imbue(lg);
   8821                             {
   8822                                 ios.width(0);
   8823                                 {
   8824                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8825                                     std::string ex(str, iter.base());
   8826                                     assert(ex == "+1_234_567_89_0;125");
   8827                                     assert(ios.width() == 0);
   8828                                 }
   8829                                 ios.width(25);
   8830                                 left(ios);
   8831                                 {
   8832                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8833                                     std::string ex(str, iter.base());
   8834                                     assert(ex == "+1_234_567_89_0;125******");
   8835                                     assert(ios.width() == 0);
   8836                                 }
   8837                                 ios.width(25);
   8838                                 right(ios);
   8839                                 {
   8840                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8841                                     std::string ex(str, iter.base());
   8842                                     assert(ex == "******+1_234_567_89_0;125");
   8843                                     assert(ios.width() == 0);
   8844                                 }
   8845                                 ios.width(25);
   8846                                 internal(ios);
   8847                                 {
   8848                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8849                                     std::string ex(str, iter.base());
   8850                                     assert(ex == "+******1_234_567_89_0;125");
   8851                                     assert(ios.width() == 0);
   8852                                 }
   8853                             }
   8854                         }
   8855                         showpoint(ios);
   8856                         {
   8857                             ios.imbue(lc);
   8858                             {
   8859                                 ios.width(0);
   8860                                 {
   8861                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8862                                     std::string ex(str, iter.base());
   8863                                     assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
   8864                                     assert(ios.width() == 0);
   8865                                 }
   8866                                 ios.width(25);
   8867                                 left(ios);
   8868                                 {
   8869                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8870                                     std::string ex(str, iter.base());
   8871                                     assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
   8872                                     assert(ios.width() == 0);
   8873                                 }
   8874                                 ios.width(25);
   8875                                 right(ios);
   8876                                 {
   8877                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8878                                     std::string ex(str, iter.base());
   8879                                     assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
   8880                                     assert(ios.width() == 0);
   8881                                 }
   8882                                 ios.width(25);
   8883                                 internal(ios);
   8884                                 {
   8885                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8886                                     std::string ex(str, iter.base());
   8887                                     assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
   8888                                     assert(ios.width() == 0);
   8889                                 }
   8890                             }
   8891                             ios.imbue(lg);
   8892                             {
   8893                                 ios.width(0);
   8894                                 {
   8895                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8896                                     std::string ex(str, iter.base());
   8897                                     assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8898                                     assert(ios.width() == 0);
   8899                                 }
   8900                                 ios.width(25);
   8901                                 left(ios);
   8902                                 {
   8903                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8904                                     std::string ex(str, iter.base());
   8905                                     assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8906                                     assert(ios.width() == 0);
   8907                                 }
   8908                                 ios.width(25);
   8909                                 right(ios);
   8910                                 {
   8911                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8912                                     std::string ex(str, iter.base());
   8913                                     assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8914                                     assert(ios.width() == 0);
   8915                                 }
   8916                                 ios.width(25);
   8917                                 internal(ios);
   8918                                 {
   8919                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8920                                     std::string ex(str, iter.base());
   8921                                     assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8922                                     assert(ios.width() == 0);
   8923                                 }
   8924                             }
   8925                         }
   8926                     }
   8927                 }
   8928             }
   8929         }
   8930     }
   8931 }
   8932 
   8933 void test4()
   8934 {
   8935     char str[200];
   8936     output_iterator<char*> iter;
   8937     std::locale lc = std::locale::classic();
   8938     std::locale lg(lc, new my_numpunct);
   8939     const my_facet f(1);
   8940     {
   8941         long double v = -INFINITY;
   8942         std::ios ios(0);
   8943         // %g
   8944         {
   8945             ios.precision(0);
   8946             {
   8947                 nouppercase(ios);
   8948                 {
   8949                     noshowpos(ios);
   8950                     {
   8951                         noshowpoint(ios);
   8952                         {
   8953                             ios.imbue(lc);
   8954                             {
   8955                                 ios.width(0);
   8956                                 {
   8957                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8958                                     std::string ex(str, iter.base());
   8959                                     assert(ex == "-inf");
   8960                                     assert(ios.width() == 0);
   8961                                 }
   8962                                 ios.width(25);
   8963                                 left(ios);
   8964                                 {
   8965                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8966                                     std::string ex(str, iter.base());
   8967                                     assert(ex == "-inf*********************");
   8968                                     assert(ios.width() == 0);
   8969                                 }
   8970                                 ios.width(25);
   8971                                 right(ios);
   8972                                 {
   8973                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8974                                     std::string ex(str, iter.base());
   8975                                     assert(ex == "*********************-inf");
   8976                                     assert(ios.width() == 0);
   8977                                 }
   8978                                 ios.width(25);
   8979                                 internal(ios);
   8980                                 {
   8981                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8982                                     std::string ex(str, iter.base());
   8983                                     assert(ex == "-*********************inf");
   8984                                     assert(ios.width() == 0);
   8985                                 }
   8986                             }
   8987                             ios.imbue(lg);
   8988                             {
   8989                                 ios.width(0);
   8990                                 {
   8991                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8992                                     std::string ex(str, iter.base());
   8993                                     assert(ex == "-inf");
   8994                                     assert(ios.width() == 0);
   8995                                 }
   8996                                 ios.width(25);
   8997                                 left(ios);
   8998                                 {
   8999                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9000                                     std::string ex(str, iter.base());
   9001                                     assert(ex == "-inf*********************");
   9002                                     assert(ios.width() == 0);
   9003                                 }
   9004                                 ios.width(25);
   9005                                 right(ios);
   9006                                 {
   9007                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9008                                     std::string ex(str, iter.base());
   9009                                     assert(ex == "*********************-inf");
   9010                                     assert(ios.width() == 0);
   9011                                 }
   9012                                 ios.width(25);
   9013                                 internal(ios);
   9014                                 {
   9015                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9016                                     std::string ex(str, iter.base());
   9017                                     assert(ex == "-*********************inf");
   9018                                     assert(ios.width() == 0);
   9019                                 }
   9020                             }
   9021                         }
   9022                         showpoint(ios);
   9023                         {
   9024                             ios.imbue(lc);
   9025                             {
   9026                                 ios.width(0);
   9027                                 {
   9028                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9029                                     std::string ex(str, iter.base());
   9030                                     assert(ex == "-inf");
   9031                                     assert(ios.width() == 0);
   9032                                 }
   9033                                 ios.width(25);
   9034                                 left(ios);
   9035                                 {
   9036                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9037                                     std::string ex(str, iter.base());
   9038                                     assert(ex == "-inf*********************");
   9039                                     assert(ios.width() == 0);
   9040                                 }
   9041                                 ios.width(25);
   9042                                 right(ios);
   9043                                 {
   9044                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9045                                     std::string ex(str, iter.base());
   9046                                     assert(ex == "*********************-inf");
   9047                                     assert(ios.width() == 0);
   9048                                 }
   9049                                 ios.width(25);
   9050                                 internal(ios);
   9051                                 {
   9052                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9053                                     std::string ex(str, iter.base());
   9054                                     assert(ex == "-*********************inf");
   9055                                     assert(ios.width() == 0);
   9056                                 }
   9057                             }
   9058                             ios.imbue(lg);
   9059                             {
   9060                                 ios.width(0);
   9061                                 {
   9062                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9063                                     std::string ex(str, iter.base());
   9064                                     assert(ex == "-inf");
   9065                                     assert(ios.width() == 0);
   9066                                 }
   9067                                 ios.width(25);
   9068                                 left(ios);
   9069                                 {
   9070                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9071                                     std::string ex(str, iter.base());
   9072                                     assert(ex == "-inf*********************");
   9073                                     assert(ios.width() == 0);
   9074                                 }
   9075                                 ios.width(25);
   9076                                 right(ios);
   9077                                 {
   9078                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9079                                     std::string ex(str, iter.base());
   9080                                     assert(ex == "*********************-inf");
   9081                                     assert(ios.width() == 0);
   9082                                 }
   9083                                 ios.width(25);
   9084                                 internal(ios);
   9085                                 {
   9086                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9087                                     std::string ex(str, iter.base());
   9088                                     assert(ex == "-*********************inf");
   9089                                     assert(ios.width() == 0);
   9090                                 }
   9091                             }
   9092                         }
   9093                     }
   9094                     showpos(ios);
   9095                     {
   9096                         noshowpoint(ios);
   9097                         {
   9098                             ios.imbue(lc);
   9099                             {
   9100                                 ios.width(0);
   9101                                 {
   9102                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9103                                     std::string ex(str, iter.base());
   9104                                     assert(ex == "-inf");
   9105                                     assert(ios.width() == 0);
   9106                                 }
   9107                                 ios.width(25);
   9108                                 left(ios);
   9109                                 {
   9110                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9111                                     std::string ex(str, iter.base());
   9112                                     assert(ex == "-inf*********************");
   9113                                     assert(ios.width() == 0);
   9114                                 }
   9115                                 ios.width(25);
   9116                                 right(ios);
   9117                                 {
   9118                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9119                                     std::string ex(str, iter.base());
   9120                                     assert(ex == "*********************-inf");
   9121                                     assert(ios.width() == 0);
   9122                                 }
   9123                                 ios.width(25);
   9124                                 internal(ios);
   9125                                 {
   9126                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9127                                     std::string ex(str, iter.base());
   9128                                     assert(ex == "-*********************inf");
   9129                                     assert(ios.width() == 0);
   9130                                 }
   9131                             }
   9132                             ios.imbue(lg);
   9133                             {
   9134                                 ios.width(0);
   9135                                 {
   9136                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9137                                     std::string ex(str, iter.base());
   9138                                     assert(ex == "-inf");
   9139                                     assert(ios.width() == 0);
   9140                                 }
   9141                                 ios.width(25);
   9142                                 left(ios);
   9143                                 {
   9144                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9145                                     std::string ex(str, iter.base());
   9146                                     assert(ex == "-inf*********************");
   9147                                     assert(ios.width() == 0);
   9148                                 }
   9149                                 ios.width(25);
   9150                                 right(ios);
   9151                                 {
   9152                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9153                                     std::string ex(str, iter.base());
   9154                                     assert(ex == "*********************-inf");
   9155                                     assert(ios.width() == 0);
   9156                                 }
   9157                                 ios.width(25);
   9158                                 internal(ios);
   9159                                 {
   9160                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9161                                     std::string ex(str, iter.base());
   9162                                     assert(ex == "-*********************inf");
   9163                                     assert(ios.width() == 0);
   9164                                 }
   9165                             }
   9166                         }
   9167                         showpoint(ios);
   9168                         {
   9169                             ios.imbue(lc);
   9170                             {
   9171                                 ios.width(0);
   9172                                 {
   9173                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9174                                     std::string ex(str, iter.base());
   9175                                     assert(ex == "-inf");
   9176                                     assert(ios.width() == 0);
   9177                                 }
   9178                                 ios.width(25);
   9179                                 left(ios);
   9180                                 {
   9181                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9182                                     std::string ex(str, iter.base());
   9183                                     assert(ex == "-inf*********************");
   9184                                     assert(ios.width() == 0);
   9185                                 }
   9186                                 ios.width(25);
   9187                                 right(ios);
   9188                                 {
   9189                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9190                                     std::string ex(str, iter.base());
   9191                                     assert(ex == "*********************-inf");
   9192                                     assert(ios.width() == 0);
   9193                                 }
   9194                                 ios.width(25);
   9195                                 internal(ios);
   9196                                 {
   9197                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9198                                     std::string ex(str, iter.base());
   9199                                     assert(ex == "-*********************inf");
   9200                                     assert(ios.width() == 0);
   9201                                 }
   9202                             }
   9203                             ios.imbue(lg);
   9204                             {
   9205                                 ios.width(0);
   9206                                 {
   9207                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9208                                     std::string ex(str, iter.base());
   9209                                     assert(ex == "-inf");
   9210                                     assert(ios.width() == 0);
   9211                                 }
   9212                                 ios.width(25);
   9213                                 left(ios);
   9214                                 {
   9215                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9216                                     std::string ex(str, iter.base());
   9217                                     assert(ex == "-inf*********************");
   9218                                     assert(ios.width() == 0);
   9219                                 }
   9220                                 ios.width(25);
   9221                                 right(ios);
   9222                                 {
   9223                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9224                                     std::string ex(str, iter.base());
   9225                                     assert(ex == "*********************-inf");
   9226                                     assert(ios.width() == 0);
   9227                                 }
   9228                                 ios.width(25);
   9229                                 internal(ios);
   9230                                 {
   9231                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9232                                     std::string ex(str, iter.base());
   9233                                     assert(ex == "-*********************inf");
   9234                                     assert(ios.width() == 0);
   9235                                 }
   9236                             }
   9237                         }
   9238                     }
   9239                 }
   9240                 uppercase(ios);
   9241                 {
   9242                     noshowpos(ios);
   9243                     {
   9244                         noshowpoint(ios);
   9245                         {
   9246                             ios.imbue(lc);
   9247                             {
   9248                                 ios.width(0);
   9249                                 {
   9250                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9251                                     std::string ex(str, iter.base());
   9252                                     assert(ex == "-INF");
   9253                                     assert(ios.width() == 0);
   9254                                 }
   9255                                 ios.width(25);
   9256                                 left(ios);
   9257                                 {
   9258                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9259                                     std::string ex(str, iter.base());
   9260                                     assert(ex == "-INF*********************");
   9261                                     assert(ios.width() == 0);
   9262                                 }
   9263                                 ios.width(25);
   9264                                 right(ios);
   9265                                 {
   9266                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9267                                     std::string ex(str, iter.base());
   9268                                     assert(ex == "*********************-INF");
   9269                                     assert(ios.width() == 0);
   9270                                 }
   9271                                 ios.width(25);
   9272                                 internal(ios);
   9273                                 {
   9274                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9275                                     std::string ex(str, iter.base());
   9276                                     assert(ex == "-*********************INF");
   9277                                     assert(ios.width() == 0);
   9278                                 }
   9279                             }
   9280                             ios.imbue(lg);
   9281                             {
   9282                                 ios.width(0);
   9283                                 {
   9284                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9285                                     std::string ex(str, iter.base());
   9286                                     assert(ex == "-INF");
   9287                                     assert(ios.width() == 0);
   9288                                 }
   9289                                 ios.width(25);
   9290                                 left(ios);
   9291                                 {
   9292                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9293                                     std::string ex(str, iter.base());
   9294                                     assert(ex == "-INF*********************");
   9295                                     assert(ios.width() == 0);
   9296                                 }
   9297                                 ios.width(25);
   9298                                 right(ios);
   9299                                 {
   9300                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9301                                     std::string ex(str, iter.base());
   9302                                     assert(ex == "*********************-INF");
   9303                                     assert(ios.width() == 0);
   9304                                 }
   9305                                 ios.width(25);
   9306                                 internal(ios);
   9307                                 {
   9308                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9309                                     std::string ex(str, iter.base());
   9310                                     assert(ex == "-*********************INF");
   9311                                     assert(ios.width() == 0);
   9312                                 }
   9313                             }
   9314                         }
   9315                         showpoint(ios);
   9316                         {
   9317                             ios.imbue(lc);
   9318                             {
   9319                                 ios.width(0);
   9320                                 {
   9321                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9322                                     std::string ex(str, iter.base());
   9323                                     assert(ex == "-INF");
   9324                                     assert(ios.width() == 0);
   9325                                 }
   9326                                 ios.width(25);
   9327                                 left(ios);
   9328                                 {
   9329                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9330                                     std::string ex(str, iter.base());
   9331                                     assert(ex == "-INF*********************");
   9332                                     assert(ios.width() == 0);
   9333                                 }
   9334                                 ios.width(25);
   9335                                 right(ios);
   9336                                 {
   9337                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9338                                     std::string ex(str, iter.base());
   9339                                     assert(ex == "*********************-INF");
   9340                                     assert(ios.width() == 0);
   9341                                 }
   9342                                 ios.width(25);
   9343                                 internal(ios);
   9344                                 {
   9345                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9346                                     std::string ex(str, iter.base());
   9347                                     assert(ex == "-*********************INF");
   9348                                     assert(ios.width() == 0);
   9349                                 }
   9350                             }
   9351                             ios.imbue(lg);
   9352                             {
   9353                                 ios.width(0);
   9354                                 {
   9355                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9356                                     std::string ex(str, iter.base());
   9357                                     assert(ex == "-INF");
   9358                                     assert(ios.width() == 0);
   9359                                 }
   9360                                 ios.width(25);
   9361                                 left(ios);
   9362                                 {
   9363                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9364                                     std::string ex(str, iter.base());
   9365                                     assert(ex == "-INF*********************");
   9366                                     assert(ios.width() == 0);
   9367                                 }
   9368                                 ios.width(25);
   9369                                 right(ios);
   9370                                 {
   9371                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9372                                     std::string ex(str, iter.base());
   9373                                     assert(ex == "*********************-INF");
   9374                                     assert(ios.width() == 0);
   9375                                 }
   9376                                 ios.width(25);
   9377                                 internal(ios);
   9378                                 {
   9379                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9380                                     std::string ex(str, iter.base());
   9381                                     assert(ex == "-*********************INF");
   9382                                     assert(ios.width() == 0);
   9383                                 }
   9384                             }
   9385                         }
   9386                     }
   9387                     showpos(ios);
   9388                     {
   9389                         noshowpoint(ios);
   9390                         {
   9391                             ios.imbue(lc);
   9392                             {
   9393                                 ios.width(0);
   9394                                 {
   9395                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9396                                     std::string ex(str, iter.base());
   9397                                     assert(ex == "-INF");
   9398                                     assert(ios.width() == 0);
   9399                                 }
   9400                                 ios.width(25);
   9401                                 left(ios);
   9402                                 {
   9403                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9404                                     std::string ex(str, iter.base());
   9405                                     assert(ex == "-INF*********************");
   9406                                     assert(ios.width() == 0);
   9407                                 }
   9408                                 ios.width(25);
   9409                                 right(ios);
   9410                                 {
   9411                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9412                                     std::string ex(str, iter.base());
   9413                                     assert(ex == "*********************-INF");
   9414                                     assert(ios.width() == 0);
   9415                                 }
   9416                                 ios.width(25);
   9417                                 internal(ios);
   9418                                 {
   9419                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9420                                     std::string ex(str, iter.base());
   9421                                     assert(ex == "-*********************INF");
   9422                                     assert(ios.width() == 0);
   9423                                 }
   9424                             }
   9425                             ios.imbue(lg);
   9426                             {
   9427                                 ios.width(0);
   9428                                 {
   9429                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9430                                     std::string ex(str, iter.base());
   9431                                     assert(ex == "-INF");
   9432                                     assert(ios.width() == 0);
   9433                                 }
   9434                                 ios.width(25);
   9435                                 left(ios);
   9436                                 {
   9437                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9438                                     std::string ex(str, iter.base());
   9439                                     assert(ex == "-INF*********************");
   9440                                     assert(ios.width() == 0);
   9441                                 }
   9442                                 ios.width(25);
   9443                                 right(ios);
   9444                                 {
   9445                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9446                                     std::string ex(str, iter.base());
   9447                                     assert(ex == "*********************-INF");
   9448                                     assert(ios.width() == 0);
   9449                                 }
   9450                                 ios.width(25);
   9451                                 internal(ios);
   9452                                 {
   9453                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9454                                     std::string ex(str, iter.base());
   9455                                     assert(ex == "-*********************INF");
   9456                                     assert(ios.width() == 0);
   9457                                 }
   9458                             }
   9459                         }
   9460                         showpoint(ios);
   9461                         {
   9462                             ios.imbue(lc);
   9463                             {
   9464                                 ios.width(0);
   9465                                 {
   9466                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9467                                     std::string ex(str, iter.base());
   9468                                     assert(ex == "-INF");
   9469                                     assert(ios.width() == 0);
   9470                                 }
   9471                                 ios.width(25);
   9472                                 left(ios);
   9473                                 {
   9474                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9475                                     std::string ex(str, iter.base());
   9476                                     assert(ex == "-INF*********************");
   9477                                     assert(ios.width() == 0);
   9478                                 }
   9479                                 ios.width(25);
   9480                                 right(ios);
   9481                                 {
   9482                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9483                                     std::string ex(str, iter.base());
   9484                                     assert(ex == "*********************-INF");
   9485                                     assert(ios.width() == 0);
   9486                                 }
   9487                                 ios.width(25);
   9488                                 internal(ios);
   9489                                 {
   9490                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9491                                     std::string ex(str, iter.base());
   9492                                     assert(ex == "-*********************INF");
   9493                                     assert(ios.width() == 0);
   9494                                 }
   9495                             }
   9496                             ios.imbue(lg);
   9497                             {
   9498                                 ios.width(0);
   9499                                 {
   9500                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9501                                     std::string ex(str, iter.base());
   9502                                     assert(ex == "-INF");
   9503                                     assert(ios.width() == 0);
   9504                                 }
   9505                                 ios.width(25);
   9506                                 left(ios);
   9507                                 {
   9508                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9509                                     std::string ex(str, iter.base());
   9510                                     assert(ex == "-INF*********************");
   9511                                     assert(ios.width() == 0);
   9512                                 }
   9513                                 ios.width(25);
   9514                                 right(ios);
   9515                                 {
   9516                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9517                                     std::string ex(str, iter.base());
   9518                                     assert(ex == "*********************-INF");
   9519                                     assert(ios.width() == 0);
   9520                                 }
   9521                                 ios.width(25);
   9522                                 internal(ios);
   9523                                 {
   9524                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9525                                     std::string ex(str, iter.base());
   9526                                     assert(ex == "-*********************INF");
   9527                                     assert(ios.width() == 0);
   9528                                 }
   9529                             }
   9530                         }
   9531                     }
   9532                 }
   9533             }
   9534             ios.precision(1);
   9535             {
   9536                 nouppercase(ios);
   9537                 {
   9538                     noshowpos(ios);
   9539                     {
   9540                         noshowpoint(ios);
   9541                         {
   9542                             ios.imbue(lc);
   9543                             {
   9544                                 ios.width(0);
   9545                                 {
   9546                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9547                                     std::string ex(str, iter.base());
   9548                                     assert(ex == "-inf");
   9549                                     assert(ios.width() == 0);
   9550                                 }
   9551                                 ios.width(25);
   9552                                 left(ios);
   9553                                 {
   9554                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9555                                     std::string ex(str, iter.base());
   9556                                     assert(ex == "-inf*********************");
   9557                                     assert(ios.width() == 0);
   9558                                 }
   9559                                 ios.width(25);
   9560                                 right(ios);
   9561                                 {
   9562                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9563                                     std::string ex(str, iter.base());
   9564                                     assert(ex == "*********************-inf");
   9565                                     assert(ios.width() == 0);
   9566                                 }
   9567                                 ios.width(25);
   9568                                 internal(ios);
   9569                                 {
   9570                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9571                                     std::string ex(str, iter.base());
   9572                                     assert(ex == "-*********************inf");
   9573                                     assert(ios.width() == 0);
   9574                                 }
   9575                             }
   9576                             ios.imbue(lg);
   9577                             {
   9578                                 ios.width(0);
   9579                                 {
   9580                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9581                                     std::string ex(str, iter.base());
   9582                                     assert(ex == "-inf");
   9583                                     assert(ios.width() == 0);
   9584                                 }
   9585                                 ios.width(25);
   9586                                 left(ios);
   9587                                 {
   9588                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9589                                     std::string ex(str, iter.base());
   9590                                     assert(ex == "-inf*********************");
   9591                                     assert(ios.width() == 0);
   9592                                 }
   9593                                 ios.width(25);
   9594                                 right(ios);
   9595                                 {
   9596                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9597                                     std::string ex(str, iter.base());
   9598                                     assert(ex == "*********************-inf");
   9599                                     assert(ios.width() == 0);
   9600                                 }
   9601                                 ios.width(25);
   9602                                 internal(ios);
   9603                                 {
   9604                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9605                                     std::string ex(str, iter.base());
   9606                                     assert(ex == "-*********************inf");
   9607                                     assert(ios.width() == 0);
   9608                                 }
   9609                             }
   9610                         }
   9611                         showpoint(ios);
   9612                         {
   9613                             ios.imbue(lc);
   9614                             {
   9615                                 ios.width(0);
   9616                                 {
   9617                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9618                                     std::string ex(str, iter.base());
   9619                                     assert(ex == "-inf");
   9620                                     assert(ios.width() == 0);
   9621                                 }
   9622                                 ios.width(25);
   9623                                 left(ios);
   9624                                 {
   9625                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9626                                     std::string ex(str, iter.base());
   9627                                     assert(ex == "-inf*********************");
   9628                                     assert(ios.width() == 0);
   9629                                 }
   9630                                 ios.width(25);
   9631                                 right(ios);
   9632                                 {
   9633                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9634                                     std::string ex(str, iter.base());
   9635                                     assert(ex == "*********************-inf");
   9636                                     assert(ios.width() == 0);
   9637                                 }
   9638                                 ios.width(25);
   9639                                 internal(ios);
   9640                                 {
   9641                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9642                                     std::string ex(str, iter.base());
   9643                                     assert(ex == "-*********************inf");
   9644                                     assert(ios.width() == 0);
   9645                                 }
   9646                             }
   9647                             ios.imbue(lg);
   9648                             {
   9649                                 ios.width(0);
   9650                                 {
   9651                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9652                                     std::string ex(str, iter.base());
   9653                                     assert(ex == "-inf");
   9654                                     assert(ios.width() == 0);
   9655                                 }
   9656                                 ios.width(25);
   9657                                 left(ios);
   9658                                 {
   9659                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9660                                     std::string ex(str, iter.base());
   9661                                     assert(ex == "-inf*********************");
   9662                                     assert(ios.width() == 0);
   9663                                 }
   9664                                 ios.width(25);
   9665                                 right(ios);
   9666                                 {
   9667                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9668                                     std::string ex(str, iter.base());
   9669                                     assert(ex == "*********************-inf");
   9670                                     assert(ios.width() == 0);
   9671                                 }
   9672                                 ios.width(25);
   9673                                 internal(ios);
   9674                                 {
   9675                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9676                                     std::string ex(str, iter.base());
   9677                                     assert(ex == "-*********************inf");
   9678                                     assert(ios.width() == 0);
   9679                                 }
   9680                             }
   9681                         }
   9682                     }
   9683                     showpos(ios);
   9684                     {
   9685                         noshowpoint(ios);
   9686                         {
   9687                             ios.imbue(lc);
   9688                             {
   9689                                 ios.width(0);
   9690                                 {
   9691                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9692                                     std::string ex(str, iter.base());
   9693                                     assert(ex == "-inf");
   9694                                     assert(ios.width() == 0);
   9695                                 }
   9696                                 ios.width(25);
   9697                                 left(ios);
   9698                                 {
   9699                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9700                                     std::string ex(str, iter.base());
   9701                                     assert(ex == "-inf*********************");
   9702                                     assert(ios.width() == 0);
   9703                                 }
   9704                                 ios.width(25);
   9705                                 right(ios);
   9706                                 {
   9707                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9708                                     std::string ex(str, iter.base());
   9709                                     assert(ex == "*********************-inf");
   9710                                     assert(ios.width() == 0);
   9711                                 }
   9712                                 ios.width(25);
   9713                                 internal(ios);
   9714                                 {
   9715                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9716                                     std::string ex(str, iter.base());
   9717                                     assert(ex == "-*********************inf");
   9718                                     assert(ios.width() == 0);
   9719                                 }
   9720                             }
   9721                             ios.imbue(lg);
   9722                             {
   9723                                 ios.width(0);
   9724                                 {
   9725                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9726                                     std::string ex(str, iter.base());
   9727                                     assert(ex == "-inf");
   9728                                     assert(ios.width() == 0);
   9729                                 }
   9730                                 ios.width(25);
   9731                                 left(ios);
   9732                                 {
   9733                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9734                                     std::string ex(str, iter.base());
   9735                                     assert(ex == "-inf*********************");
   9736                                     assert(ios.width() == 0);
   9737                                 }
   9738                                 ios.width(25);
   9739                                 right(ios);
   9740                                 {
   9741                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9742                                     std::string ex(str, iter.base());
   9743                                     assert(ex == "*********************-inf");
   9744                                     assert(ios.width() == 0);
   9745                                 }
   9746                                 ios.width(25);
   9747                                 internal(ios);
   9748                                 {
   9749                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9750                                     std::string ex(str, iter.base());
   9751                                     assert(ex == "-*********************inf");
   9752                                     assert(ios.width() == 0);
   9753                                 }
   9754                             }
   9755                         }
   9756                         showpoint(ios);
   9757                         {
   9758                             ios.imbue(lc);
   9759                             {
   9760                                 ios.width(0);
   9761                                 {
   9762                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9763                                     std::string ex(str, iter.base());
   9764                                     assert(ex == "-inf");
   9765                                     assert(ios.width() == 0);
   9766                                 }
   9767                                 ios.width(25);
   9768                                 left(ios);
   9769                                 {
   9770                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9771                                     std::string ex(str, iter.base());
   9772                                     assert(ex == "-inf*********************");
   9773                                     assert(ios.width() == 0);
   9774                                 }
   9775                                 ios.width(25);
   9776                                 right(ios);
   9777                                 {
   9778                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9779                                     std::string ex(str, iter.base());
   9780                                     assert(ex == "*********************-inf");
   9781                                     assert(ios.width() == 0);
   9782                                 }
   9783                                 ios.width(25);
   9784                                 internal(ios);
   9785                                 {
   9786                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9787                                     std::string ex(str, iter.base());
   9788                                     assert(ex == "-*********************inf");
   9789                                     assert(ios.width() == 0);
   9790                                 }
   9791                             }
   9792                             ios.imbue(lg);
   9793                             {
   9794                                 ios.width(0);
   9795                                 {
   9796                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9797                                     std::string ex(str, iter.base());
   9798                                     assert(ex == "-inf");
   9799                                     assert(ios.width() == 0);
   9800                                 }
   9801                                 ios.width(25);
   9802                                 left(ios);
   9803                                 {
   9804                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9805                                     std::string ex(str, iter.base());
   9806                                     assert(ex == "-inf*********************");
   9807                                     assert(ios.width() == 0);
   9808                                 }
   9809                                 ios.width(25);
   9810                                 right(ios);
   9811                                 {
   9812                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9813                                     std::string ex(str, iter.base());
   9814                                     assert(ex == "*********************-inf");
   9815                                     assert(ios.width() == 0);
   9816                                 }
   9817                                 ios.width(25);
   9818                                 internal(ios);
   9819                                 {
   9820                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9821                                     std::string ex(str, iter.base());
   9822                                     assert(ex == "-*********************inf");
   9823                                     assert(ios.width() == 0);
   9824                                 }
   9825                             }
   9826                         }
   9827                     }
   9828                 }
   9829                 uppercase(ios);
   9830                 {
   9831                     noshowpos(ios);
   9832                     {
   9833                         noshowpoint(ios);
   9834                         {
   9835                             ios.imbue(lc);
   9836                             {
   9837                                 ios.width(0);
   9838                                 {
   9839                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9840                                     std::string ex(str, iter.base());
   9841                                     assert(ex == "-INF");
   9842                                     assert(ios.width() == 0);
   9843                                 }
   9844                                 ios.width(25);
   9845                                 left(ios);
   9846                                 {
   9847                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9848                                     std::string ex(str, iter.base());
   9849                                     assert(ex == "-INF*********************");
   9850                                     assert(ios.width() == 0);
   9851                                 }
   9852                                 ios.width(25);
   9853                                 right(ios);
   9854                                 {
   9855                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9856                                     std::string ex(str, iter.base());
   9857                                     assert(ex == "*********************-INF");
   9858                                     assert(ios.width() == 0);
   9859                                 }
   9860                                 ios.width(25);
   9861                                 internal(ios);
   9862                                 {
   9863                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9864                                     std::string ex(str, iter.base());
   9865                                     assert(ex == "-*********************INF");
   9866                                     assert(ios.width() == 0);
   9867                                 }
   9868                             }
   9869                             ios.imbue(lg);
   9870                             {
   9871                                 ios.width(0);
   9872                                 {
   9873                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9874                                     std::string ex(str, iter.base());
   9875                                     assert(ex == "-INF");
   9876                                     assert(ios.width() == 0);
   9877                                 }
   9878                                 ios.width(25);
   9879                                 left(ios);
   9880                                 {
   9881                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9882                                     std::string ex(str, iter.base());
   9883                                     assert(ex == "-INF*********************");
   9884                                     assert(ios.width() == 0);
   9885                                 }
   9886                                 ios.width(25);
   9887                                 right(ios);
   9888                                 {
   9889                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9890                                     std::string ex(str, iter.base());
   9891                                     assert(ex == "*********************-INF");
   9892                                     assert(ios.width() == 0);
   9893                                 }
   9894                                 ios.width(25);
   9895                                 internal(ios);
   9896                                 {
   9897                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9898                                     std::string ex(str, iter.base());
   9899                                     assert(ex == "-*********************INF");
   9900                                     assert(ios.width() == 0);
   9901                                 }
   9902                             }
   9903                         }
   9904                         showpoint(ios);
   9905                         {
   9906                             ios.imbue(lc);
   9907                             {
   9908                                 ios.width(0);
   9909                                 {
   9910                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9911                                     std::string ex(str, iter.base());
   9912                                     assert(ex == "-INF");
   9913                                     assert(ios.width() == 0);
   9914                                 }
   9915                                 ios.width(25);
   9916                                 left(ios);
   9917                                 {
   9918                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9919                                     std::string ex(str, iter.base());
   9920                                     assert(ex == "-INF*********************");
   9921                                     assert(ios.width() == 0);
   9922                                 }
   9923                                 ios.width(25);
   9924                                 right(ios);
   9925                                 {
   9926                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9927                                     std::string ex(str, iter.base());
   9928                                     assert(ex == "*********************-INF");
   9929                                     assert(ios.width() == 0);
   9930                                 }
   9931                                 ios.width(25);
   9932                                 internal(ios);
   9933                                 {
   9934                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9935                                     std::string ex(str, iter.base());
   9936                                     assert(ex == "-*********************INF");
   9937                                     assert(ios.width() == 0);
   9938                                 }
   9939                             }
   9940                             ios.imbue(lg);
   9941                             {
   9942                                 ios.width(0);
   9943                                 {
   9944                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9945                                     std::string ex(str, iter.base());
   9946                                     assert(ex == "-INF");
   9947                                     assert(ios.width() == 0);
   9948                                 }
   9949                                 ios.width(25);
   9950                                 left(ios);
   9951                                 {
   9952                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9953                                     std::string ex(str, iter.base());
   9954                                     assert(ex == "-INF*********************");
   9955                                     assert(ios.width() == 0);
   9956                                 }
   9957                                 ios.width(25);
   9958                                 right(ios);
   9959                                 {
   9960                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9961                                     std::string ex(str, iter.base());
   9962                                     assert(ex == "*********************-INF");
   9963                                     assert(ios.width() == 0);
   9964                                 }
   9965                                 ios.width(25);
   9966                                 internal(ios);
   9967                                 {
   9968                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9969                                     std::string ex(str, iter.base());
   9970                                     assert(ex == "-*********************INF");
   9971                                     assert(ios.width() == 0);
   9972                                 }
   9973                             }
   9974                         }
   9975                     }
   9976                     showpos(ios);
   9977                     {
   9978                         noshowpoint(ios);
   9979                         {
   9980                             ios.imbue(lc);
   9981                             {
   9982                                 ios.width(0);
   9983                                 {
   9984                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9985                                     std::string ex(str, iter.base());
   9986                                     assert(ex == "-INF");
   9987                                     assert(ios.width() == 0);
   9988                                 }
   9989                                 ios.width(25);
   9990                                 left(ios);
   9991                                 {
   9992                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9993                                     std::string ex(str, iter.base());
   9994                                     assert(ex == "-INF*********************");
   9995                                     assert(ios.width() == 0);
   9996                                 }
   9997                                 ios.width(25);
   9998                                 right(ios);
   9999                                 {
   10000                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10001                                     std::string ex(str, iter.base());
   10002                                     assert(ex == "*********************-INF");
   10003                                     assert(ios.width() == 0);
   10004                                 }
   10005                                 ios.width(25);
   10006                                 internal(ios);
   10007                                 {
   10008                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10009                                     std::string ex(str, iter.base());
   10010                                     assert(ex == "-*********************INF");
   10011                                     assert(ios.width() == 0);
   10012                                 }
   10013                             }
   10014                             ios.imbue(lg);
   10015                             {
   10016                                 ios.width(0);
   10017                                 {
   10018                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10019                                     std::string ex(str, iter.base());
   10020                                     assert(ex == "-INF");
   10021                                     assert(ios.width() == 0);
   10022                                 }
   10023                                 ios.width(25);
   10024                                 left(ios);
   10025                                 {
   10026                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10027                                     std::string ex(str, iter.base());
   10028                                     assert(ex == "-INF*********************");
   10029                                     assert(ios.width() == 0);
   10030                                 }
   10031                                 ios.width(25);
   10032                                 right(ios);
   10033                                 {
   10034                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10035                                     std::string ex(str, iter.base());
   10036                                     assert(ex == "*********************-INF");
   10037                                     assert(ios.width() == 0);
   10038                                 }
   10039                                 ios.width(25);
   10040                                 internal(ios);
   10041                                 {
   10042                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10043                                     std::string ex(str, iter.base());
   10044                                     assert(ex == "-*********************INF");
   10045                                     assert(ios.width() == 0);
   10046                                 }
   10047                             }
   10048                         }
   10049                         showpoint(ios);
   10050                         {
   10051                             ios.imbue(lc);
   10052                             {
   10053                                 ios.width(0);
   10054                                 {
   10055                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10056                                     std::string ex(str, iter.base());
   10057                                     assert(ex == "-INF");
   10058                                     assert(ios.width() == 0);
   10059                                 }
   10060                                 ios.width(25);
   10061                                 left(ios);
   10062                                 {
   10063                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10064                                     std::string ex(str, iter.base());
   10065                                     assert(ex == "-INF*********************");
   10066                                     assert(ios.width() == 0);
   10067                                 }
   10068                                 ios.width(25);
   10069                                 right(ios);
   10070                                 {
   10071                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10072                                     std::string ex(str, iter.base());
   10073                                     assert(ex == "*********************-INF");
   10074                                     assert(ios.width() == 0);
   10075                                 }
   10076                                 ios.width(25);
   10077                                 internal(ios);
   10078                                 {
   10079                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10080                                     std::string ex(str, iter.base());
   10081                                     assert(ex == "-*********************INF");
   10082                                     assert(ios.width() == 0);
   10083                                 }
   10084                             }
   10085                             ios.imbue(lg);
   10086                             {
   10087                                 ios.width(0);
   10088                                 {
   10089                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10090                                     std::string ex(str, iter.base());
   10091                                     assert(ex == "-INF");
   10092                                     assert(ios.width() == 0);
   10093                                 }
   10094                                 ios.width(25);
   10095                                 left(ios);
   10096                                 {
   10097                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10098                                     std::string ex(str, iter.base());
   10099                                     assert(ex == "-INF*********************");
   10100                                     assert(ios.width() == 0);
   10101                                 }
   10102                                 ios.width(25);
   10103                                 right(ios);
   10104                                 {
   10105                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10106                                     std::string ex(str, iter.base());
   10107                                     assert(ex == "*********************-INF");
   10108                                     assert(ios.width() == 0);
   10109                                 }
   10110                                 ios.width(25);
   10111                                 internal(ios);
   10112                                 {
   10113                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10114                                     std::string ex(str, iter.base());
   10115                                     assert(ex == "-*********************INF");
   10116                                     assert(ios.width() == 0);
   10117                                 }
   10118                             }
   10119                         }
   10120                     }
   10121                 }
   10122             }
   10123             ios.precision(6);
   10124             {
   10125                 nouppercase(ios);
   10126                 {
   10127                     noshowpos(ios);
   10128                     {
   10129                         noshowpoint(ios);
   10130                         {
   10131                             ios.imbue(lc);
   10132                             {
   10133                                 ios.width(0);
   10134                                 {
   10135                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10136                                     std::string ex(str, iter.base());
   10137                                     assert(ex == "-inf");
   10138                                     assert(ios.width() == 0);
   10139                                 }
   10140                                 ios.width(25);
   10141                                 left(ios);
   10142                                 {
   10143                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10144                                     std::string ex(str, iter.base());
   10145                                     assert(ex == "-inf*********************");
   10146                                     assert(ios.width() == 0);
   10147                                 }
   10148                                 ios.width(25);
   10149                                 right(ios);
   10150                                 {
   10151                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10152                                     std::string ex(str, iter.base());
   10153                                     assert(ex == "*********************-inf");
   10154                                     assert(ios.width() == 0);
   10155                                 }
   10156                                 ios.width(25);
   10157                                 internal(ios);
   10158                                 {
   10159                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10160                                     std::string ex(str, iter.base());
   10161                                     assert(ex == "-*********************inf");
   10162                                     assert(ios.width() == 0);
   10163                                 }
   10164                             }
   10165                             ios.imbue(lg);
   10166                             {
   10167                                 ios.width(0);
   10168                                 {
   10169                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10170                                     std::string ex(str, iter.base());
   10171                                     assert(ex == "-inf");
   10172                                     assert(ios.width() == 0);
   10173                                 }
   10174                                 ios.width(25);
   10175                                 left(ios);
   10176                                 {
   10177                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10178                                     std::string ex(str, iter.base());
   10179                                     assert(ex == "-inf*********************");
   10180                                     assert(ios.width() == 0);
   10181                                 }
   10182                                 ios.width(25);
   10183                                 right(ios);
   10184                                 {
   10185                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10186                                     std::string ex(str, iter.base());
   10187                                     assert(ex == "*********************-inf");
   10188                                     assert(ios.width() == 0);
   10189                                 }
   10190                                 ios.width(25);
   10191                                 internal(ios);
   10192                                 {
   10193                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10194                                     std::string ex(str, iter.base());
   10195                                     assert(ex == "-*********************inf");
   10196                                     assert(ios.width() == 0);
   10197                                 }
   10198                             }
   10199                         }
   10200                         showpoint(ios);
   10201                         {
   10202                             ios.imbue(lc);
   10203                             {
   10204                                 ios.width(0);
   10205                                 {
   10206                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10207                                     std::string ex(str, iter.base());
   10208                                     assert(ex == "-inf");
   10209                                     assert(ios.width() == 0);
   10210                                 }
   10211                                 ios.width(25);
   10212                                 left(ios);
   10213                                 {
   10214                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10215                                     std::string ex(str, iter.base());
   10216                                     assert(ex == "-inf*********************");
   10217                                     assert(ios.width() == 0);
   10218                                 }
   10219                                 ios.width(25);
   10220                                 right(ios);
   10221                                 {
   10222                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10223                                     std::string ex(str, iter.base());
   10224                                     assert(ex == "*********************-inf");
   10225                                     assert(ios.width() == 0);
   10226                                 }
   10227                                 ios.width(25);
   10228                                 internal(ios);
   10229                                 {
   10230                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10231                                     std::string ex(str, iter.base());
   10232                                     assert(ex == "-*********************inf");
   10233                                     assert(ios.width() == 0);
   10234                                 }
   10235                             }
   10236                             ios.imbue(lg);
   10237                             {
   10238                                 ios.width(0);
   10239                                 {
   10240                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10241                                     std::string ex(str, iter.base());
   10242                                     assert(ex == "-inf");
   10243                                     assert(ios.width() == 0);
   10244                                 }
   10245                                 ios.width(25);
   10246                                 left(ios);
   10247                                 {
   10248                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10249                                     std::string ex(str, iter.base());
   10250                                     assert(ex == "-inf*********************");
   10251                                     assert(ios.width() == 0);
   10252                                 }
   10253                                 ios.width(25);
   10254                                 right(ios);
   10255                                 {
   10256                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10257                                     std::string ex(str, iter.base());
   10258                                     assert(ex == "*********************-inf");
   10259                                     assert(ios.width() == 0);
   10260                                 }
   10261                                 ios.width(25);
   10262                                 internal(ios);
   10263                                 {
   10264                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10265                                     std::string ex(str, iter.base());
   10266                                     assert(ex == "-*********************inf");
   10267                                     assert(ios.width() == 0);
   10268                                 }
   10269                             }
   10270                         }
   10271                     }
   10272                     showpos(ios);
   10273                     {
   10274                         noshowpoint(ios);
   10275                         {
   10276                             ios.imbue(lc);
   10277                             {
   10278                                 ios.width(0);
   10279                                 {
   10280                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10281                                     std::string ex(str, iter.base());
   10282                                     assert(ex == "-inf");
   10283                                     assert(ios.width() == 0);
   10284                                 }
   10285                                 ios.width(25);
   10286                                 left(ios);
   10287                                 {
   10288                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10289                                     std::string ex(str, iter.base());
   10290                                     assert(ex == "-inf*********************");
   10291                                     assert(ios.width() == 0);
   10292                                 }
   10293                                 ios.width(25);
   10294                                 right(ios);
   10295                                 {
   10296                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10297                                     std::string ex(str, iter.base());
   10298                                     assert(ex == "*********************-inf");
   10299                                     assert(ios.width() == 0);
   10300                                 }
   10301                                 ios.width(25);
   10302                                 internal(ios);
   10303                                 {
   10304                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10305                                     std::string ex(str, iter.base());
   10306                                     assert(ex == "-*********************inf");
   10307                                     assert(ios.width() == 0);
   10308                                 }
   10309                             }
   10310                             ios.imbue(lg);
   10311                             {
   10312                                 ios.width(0);
   10313                                 {
   10314                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10315                                     std::string ex(str, iter.base());
   10316                                     assert(ex == "-inf");
   10317                                     assert(ios.width() == 0);
   10318                                 }
   10319                                 ios.width(25);
   10320                                 left(ios);
   10321                                 {
   10322                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10323                                     std::string ex(str, iter.base());
   10324                                     assert(ex == "-inf*********************");
   10325                                     assert(ios.width() == 0);
   10326                                 }
   10327                                 ios.width(25);
   10328                                 right(ios);
   10329                                 {
   10330                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10331                                     std::string ex(str, iter.base());
   10332                                     assert(ex == "*********************-inf");
   10333                                     assert(ios.width() == 0);
   10334                                 }
   10335                                 ios.width(25);
   10336                                 internal(ios);
   10337                                 {
   10338                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10339                                     std::string ex(str, iter.base());
   10340                                     assert(ex == "-*********************inf");
   10341                                     assert(ios.width() == 0);
   10342                                 }
   10343                             }
   10344                         }
   10345                         showpoint(ios);
   10346                         {
   10347                             ios.imbue(lc);
   10348                             {
   10349                                 ios.width(0);
   10350                                 {
   10351                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10352                                     std::string ex(str, iter.base());
   10353                                     assert(ex == "-inf");
   10354                                     assert(ios.width() == 0);
   10355                                 }
   10356                                 ios.width(25);
   10357                                 left(ios);
   10358                                 {
   10359                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10360                                     std::string ex(str, iter.base());
   10361                                     assert(ex == "-inf*********************");
   10362                                     assert(ios.width() == 0);
   10363                                 }
   10364                                 ios.width(25);
   10365                                 right(ios);
   10366                                 {
   10367                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10368                                     std::string ex(str, iter.base());
   10369                                     assert(ex == "*********************-inf");
   10370                                     assert(ios.width() == 0);
   10371                                 }
   10372                                 ios.width(25);
   10373                                 internal(ios);
   10374                                 {
   10375                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10376                                     std::string ex(str, iter.base());
   10377                                     assert(ex == "-*********************inf");
   10378                                     assert(ios.width() == 0);
   10379                                 }
   10380                             }
   10381                             ios.imbue(lg);
   10382                             {
   10383                                 ios.width(0);
   10384                                 {
   10385                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10386                                     std::string ex(str, iter.base());
   10387                                     assert(ex == "-inf");
   10388                                     assert(ios.width() == 0);
   10389                                 }
   10390                                 ios.width(25);
   10391                                 left(ios);
   10392                                 {
   10393                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10394                                     std::string ex(str, iter.base());
   10395                                     assert(ex == "-inf*********************");
   10396                                     assert(ios.width() == 0);
   10397                                 }
   10398                                 ios.width(25);
   10399                                 right(ios);
   10400                                 {
   10401                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10402                                     std::string ex(str, iter.base());
   10403                                     assert(ex == "*********************-inf");
   10404                                     assert(ios.width() == 0);
   10405                                 }
   10406                                 ios.width(25);
   10407                                 internal(ios);
   10408                                 {
   10409                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10410                                     std::string ex(str, iter.base());
   10411                                     assert(ex == "-*********************inf");
   10412                                     assert(ios.width() == 0);
   10413                                 }
   10414                             }
   10415                         }
   10416                     }
   10417                 }
   10418                 uppercase(ios);
   10419                 {
   10420                     noshowpos(ios);
   10421                     {
   10422                         noshowpoint(ios);
   10423                         {
   10424                             ios.imbue(lc);
   10425                             {
   10426                                 ios.width(0);
   10427                                 {
   10428                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10429                                     std::string ex(str, iter.base());
   10430                                     assert(ex == "-INF");
   10431                                     assert(ios.width() == 0);
   10432                                 }
   10433                                 ios.width(25);
   10434                                 left(ios);
   10435                                 {
   10436                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10437                                     std::string ex(str, iter.base());
   10438                                     assert(ex == "-INF*********************");
   10439                                     assert(ios.width() == 0);
   10440                                 }
   10441                                 ios.width(25);
   10442                                 right(ios);
   10443                                 {
   10444                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10445                                     std::string ex(str, iter.base());
   10446                                     assert(ex == "*********************-INF");
   10447                                     assert(ios.width() == 0);
   10448                                 }
   10449                                 ios.width(25);
   10450                                 internal(ios);
   10451                                 {
   10452                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10453                                     std::string ex(str, iter.base());
   10454                                     assert(ex == "-*********************INF");
   10455                                     assert(ios.width() == 0);
   10456                                 }
   10457                             }
   10458                             ios.imbue(lg);
   10459                             {
   10460                                 ios.width(0);
   10461                                 {
   10462                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10463                                     std::string ex(str, iter.base());
   10464                                     assert(ex == "-INF");
   10465                                     assert(ios.width() == 0);
   10466                                 }
   10467                                 ios.width(25);
   10468                                 left(ios);
   10469                                 {
   10470                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10471                                     std::string ex(str, iter.base());
   10472                                     assert(ex == "-INF*********************");
   10473                                     assert(ios.width() == 0);
   10474                                 }
   10475                                 ios.width(25);
   10476                                 right(ios);
   10477                                 {
   10478                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10479                                     std::string ex(str, iter.base());
   10480                                     assert(ex == "*********************-INF");
   10481                                     assert(ios.width() == 0);
   10482                                 }
   10483                                 ios.width(25);
   10484                                 internal(ios);
   10485                                 {
   10486                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10487                                     std::string ex(str, iter.base());
   10488                                     assert(ex == "-*********************INF");
   10489                                     assert(ios.width() == 0);
   10490                                 }
   10491                             }
   10492                         }
   10493                         showpoint(ios);
   10494                         {
   10495                             ios.imbue(lc);
   10496                             {
   10497                                 ios.width(0);
   10498                                 {
   10499                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10500                                     std::string ex(str, iter.base());
   10501                                     assert(ex == "-INF");
   10502                                     assert(ios.width() == 0);
   10503                                 }
   10504                                 ios.width(25);
   10505                                 left(ios);
   10506                                 {
   10507                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10508                                     std::string ex(str, iter.base());
   10509                                     assert(ex == "-INF*********************");
   10510                                     assert(ios.width() == 0);
   10511                                 }
   10512                                 ios.width(25);
   10513                                 right(ios);
   10514                                 {
   10515                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10516                                     std::string ex(str, iter.base());
   10517                                     assert(ex == "*********************-INF");
   10518                                     assert(ios.width() == 0);
   10519                                 }
   10520                                 ios.width(25);
   10521                                 internal(ios);
   10522                                 {
   10523                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10524                                     std::string ex(str, iter.base());
   10525                                     assert(ex == "-*********************INF");
   10526                                     assert(ios.width() == 0);
   10527                                 }
   10528                             }
   10529                             ios.imbue(lg);
   10530                             {
   10531                                 ios.width(0);
   10532                                 {
   10533                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10534                                     std::string ex(str, iter.base());
   10535                                     assert(ex == "-INF");
   10536                                     assert(ios.width() == 0);
   10537                                 }
   10538                                 ios.width(25);
   10539                                 left(ios);
   10540                                 {
   10541                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10542                                     std::string ex(str, iter.base());
   10543                                     assert(ex == "-INF*********************");
   10544                                     assert(ios.width() == 0);
   10545                                 }
   10546                                 ios.width(25);
   10547                                 right(ios);
   10548                                 {
   10549                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10550                                     std::string ex(str, iter.base());
   10551                                     assert(ex == "*********************-INF");
   10552                                     assert(ios.width() == 0);
   10553                                 }
   10554                                 ios.width(25);
   10555                                 internal(ios);
   10556                                 {
   10557                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10558                                     std::string ex(str, iter.base());
   10559                                     assert(ex == "-*********************INF");
   10560                                     assert(ios.width() == 0);
   10561                                 }
   10562                             }
   10563                         }
   10564                     }
   10565                     showpos(ios);
   10566                     {
   10567                         noshowpoint(ios);
   10568                         {
   10569                             ios.imbue(lc);
   10570                             {
   10571                                 ios.width(0);
   10572                                 {
   10573                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10574                                     std::string ex(str, iter.base());
   10575                                     assert(ex == "-INF");
   10576                                     assert(ios.width() == 0);
   10577                                 }
   10578                                 ios.width(25);
   10579                                 left(ios);
   10580                                 {
   10581                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10582                                     std::string ex(str, iter.base());
   10583                                     assert(ex == "-INF*********************");
   10584                                     assert(ios.width() == 0);
   10585                                 }
   10586                                 ios.width(25);
   10587                                 right(ios);
   10588                                 {
   10589                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10590                                     std::string ex(str, iter.base());
   10591                                     assert(ex == "*********************-INF");
   10592                                     assert(ios.width() == 0);
   10593                                 }
   10594                                 ios.width(25);
   10595                                 internal(ios);
   10596                                 {
   10597                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10598                                     std::string ex(str, iter.base());
   10599                                     assert(ex == "-*********************INF");
   10600                                     assert(ios.width() == 0);
   10601                                 }
   10602                             }
   10603                             ios.imbue(lg);
   10604                             {
   10605                                 ios.width(0);
   10606                                 {
   10607                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10608                                     std::string ex(str, iter.base());
   10609                                     assert(ex == "-INF");
   10610                                     assert(ios.width() == 0);
   10611                                 }
   10612                                 ios.width(25);
   10613                                 left(ios);
   10614                                 {
   10615                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10616                                     std::string ex(str, iter.base());
   10617                                     assert(ex == "-INF*********************");
   10618                                     assert(ios.width() == 0);
   10619                                 }
   10620                                 ios.width(25);
   10621                                 right(ios);
   10622                                 {
   10623                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10624                                     std::string ex(str, iter.base());
   10625                                     assert(ex == "*********************-INF");
   10626                                     assert(ios.width() == 0);
   10627                                 }
   10628                                 ios.width(25);
   10629                                 internal(ios);
   10630                                 {
   10631                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10632                                     std::string ex(str, iter.base());
   10633                                     assert(ex == "-*********************INF");
   10634                                     assert(ios.width() == 0);
   10635                                 }
   10636                             }
   10637                         }
   10638                         showpoint(ios);
   10639                         {
   10640                             ios.imbue(lc);
   10641                             {
   10642                                 ios.width(0);
   10643                                 {
   10644                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10645                                     std::string ex(str, iter.base());
   10646                                     assert(ex == "-INF");
   10647                                     assert(ios.width() == 0);
   10648                                 }
   10649                                 ios.width(25);
   10650                                 left(ios);
   10651                                 {
   10652                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10653                                     std::string ex(str, iter.base());
   10654                                     assert(ex == "-INF*********************");
   10655                                     assert(ios.width() == 0);
   10656                                 }
   10657                                 ios.width(25);
   10658                                 right(ios);
   10659                                 {
   10660                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10661                                     std::string ex(str, iter.base());
   10662                                     assert(ex == "*********************-INF");
   10663                                     assert(ios.width() == 0);
   10664                                 }
   10665                                 ios.width(25);
   10666                                 internal(ios);
   10667                                 {
   10668                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10669                                     std::string ex(str, iter.base());
   10670                                     assert(ex == "-*********************INF");
   10671                                     assert(ios.width() == 0);
   10672                                 }
   10673                             }
   10674                             ios.imbue(lg);
   10675                             {
   10676                                 ios.width(0);
   10677                                 {
   10678                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10679                                     std::string ex(str, iter.base());
   10680                                     assert(ex == "-INF");
   10681                                     assert(ios.width() == 0);
   10682                                 }
   10683                                 ios.width(25);
   10684                                 left(ios);
   10685                                 {
   10686                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10687                                     std::string ex(str, iter.base());
   10688                                     assert(ex == "-INF*********************");
   10689                                     assert(ios.width() == 0);
   10690                                 }
   10691                                 ios.width(25);
   10692                                 right(ios);
   10693                                 {
   10694                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10695                                     std::string ex(str, iter.base());
   10696                                     assert(ex == "*********************-INF");
   10697                                     assert(ios.width() == 0);
   10698                                 }
   10699                                 ios.width(25);
   10700                                 internal(ios);
   10701                                 {
   10702                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10703                                     std::string ex(str, iter.base());
   10704                                     assert(ex == "-*********************INF");
   10705                                     assert(ios.width() == 0);
   10706                                 }
   10707                             }
   10708                         }
   10709                     }
   10710                 }
   10711             }
   10712             ios.precision(16);
   10713             {}
   10714             ios.precision(60);
   10715             {}
   10716         }
   10717     }
   10718 }
   10719 
   10720 void test5()
   10721 {
   10722     char str[200];
   10723     output_iterator<char*> iter;
   10724     std::locale lc = std::locale::classic();
   10725     std::locale lg(lc, new my_numpunct);
   10726     const my_facet f(1);
   10727     {
   10728         long double v = std::nan("");
   10729         std::ios ios(0);
   10730         // %g
   10731         {
   10732             ios.precision(0);
   10733             {
   10734                 nouppercase(ios);
   10735                 {
   10736                     noshowpos(ios);
   10737                     {
   10738                         noshowpoint(ios);
   10739                         {
   10740                             ios.imbue(lc);
   10741                             {
   10742                                 ios.width(0);
   10743                                 {
   10744                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10745                                     std::string ex(str, iter.base());
   10746                                     assert(ex == "nan");
   10747                                     assert(ios.width() == 0);
   10748                                 }
   10749                                 ios.width(25);
   10750                                 left(ios);
   10751                                 {
   10752                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10753                                     std::string ex(str, iter.base());
   10754                                     assert(ex == "nan**********************");
   10755                                     assert(ios.width() == 0);
   10756                                 }
   10757                                 ios.width(25);
   10758                                 right(ios);
   10759                                 {
   10760                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10761                                     std::string ex(str, iter.base());
   10762                                     assert(ex == "**********************nan");
   10763                                     assert(ios.width() == 0);
   10764                                 }
   10765                                 ios.width(25);
   10766                                 internal(ios);
   10767                                 {
   10768                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10769                                     std::string ex(str, iter.base());
   10770                                     assert(ex == "**********************nan");
   10771                                     assert(ios.width() == 0);
   10772                                 }
   10773                             }
   10774                             ios.imbue(lg);
   10775                             {
   10776                                 ios.width(0);
   10777                                 {
   10778                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10779                                     std::string ex(str, iter.base());
   10780                                     assert(ex == "nan");
   10781                                     assert(ios.width() == 0);
   10782                                 }
   10783                                 ios.width(25);
   10784                                 left(ios);
   10785                                 {
   10786                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10787                                     std::string ex(str, iter.base());
   10788                                     assert(ex == "nan**********************");
   10789                                     assert(ios.width() == 0);
   10790                                 }
   10791                                 ios.width(25);
   10792                                 right(ios);
   10793                                 {
   10794                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10795                                     std::string ex(str, iter.base());
   10796                                     assert(ex == "**********************nan");
   10797                                     assert(ios.width() == 0);
   10798                                 }
   10799                                 ios.width(25);
   10800                                 internal(ios);
   10801                                 {
   10802                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10803                                     std::string ex(str, iter.base());
   10804                                     assert(ex == "**********************nan");
   10805                                     assert(ios.width() == 0);
   10806                                 }
   10807                             }
   10808                         }
   10809                         showpoint(ios);
   10810                         {
   10811                             ios.imbue(lc);
   10812                             {
   10813                                 ios.width(0);
   10814                                 {
   10815                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10816                                     std::string ex(str, iter.base());
   10817                                     assert(ex == "nan");
   10818                                     assert(ios.width() == 0);
   10819                                 }
   10820                                 ios.width(25);
   10821                                 left(ios);
   10822                                 {
   10823                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10824                                     std::string ex(str, iter.base());
   10825                                     assert(ex == "nan**********************");
   10826                                     assert(ios.width() == 0);
   10827                                 }
   10828                                 ios.width(25);
   10829                                 right(ios);
   10830                                 {
   10831                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10832                                     std::string ex(str, iter.base());
   10833                                     assert(ex == "**********************nan");
   10834                                     assert(ios.width() == 0);
   10835                                 }
   10836                                 ios.width(25);
   10837                                 internal(ios);
   10838                                 {
   10839                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10840                                     std::string ex(str, iter.base());
   10841                                     assert(ex == "**********************nan");
   10842                                     assert(ios.width() == 0);
   10843                                 }
   10844                             }
   10845                             ios.imbue(lg);
   10846                             {
   10847                                 ios.width(0);
   10848                                 {
   10849                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10850                                     std::string ex(str, iter.base());
   10851                                     assert(ex == "nan");
   10852                                     assert(ios.width() == 0);
   10853                                 }
   10854                                 ios.width(25);
   10855                                 left(ios);
   10856                                 {
   10857                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10858                                     std::string ex(str, iter.base());
   10859                                     assert(ex == "nan**********************");
   10860                                     assert(ios.width() == 0);
   10861                                 }
   10862                                 ios.width(25);
   10863                                 right(ios);
   10864                                 {
   10865                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10866                                     std::string ex(str, iter.base());
   10867                                     assert(ex == "**********************nan");
   10868                                     assert(ios.width() == 0);
   10869                                 }
   10870                                 ios.width(25);
   10871                                 internal(ios);
   10872                                 {
   10873                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10874                                     std::string ex(str, iter.base());
   10875                                     assert(ex == "**********************nan");
   10876                                     assert(ios.width() == 0);
   10877                                 }
   10878                             }
   10879                         }
   10880                     }
   10881                     showpos(ios);
   10882                     {
   10883                         noshowpoint(ios);
   10884                         {
   10885                             ios.imbue(lc);
   10886                             {
   10887                                 ios.width(0);
   10888                                 {
   10889                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10890                                     std::string ex(str, iter.base());
   10891                                     assert(ex == "nan");
   10892                                     assert(ios.width() == 0);
   10893                                 }
   10894                                 ios.width(25);
   10895                                 left(ios);
   10896                                 {
   10897                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10898                                     std::string ex(str, iter.base());
   10899                                     assert(ex == "nan**********************");
   10900                                     assert(ios.width() == 0);
   10901                                 }
   10902                                 ios.width(25);
   10903                                 right(ios);
   10904                                 {
   10905                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10906                                     std::string ex(str, iter.base());
   10907                                     assert(ex == "**********************nan");
   10908                                     assert(ios.width() == 0);
   10909                                 }
   10910                                 ios.width(25);
   10911                                 internal(ios);
   10912                                 {
   10913                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10914                                     std::string ex(str, iter.base());
   10915                                     assert(ex == "**********************nan");
   10916                                     assert(ios.width() == 0);
   10917                                 }
   10918                             }
   10919                             ios.imbue(lg);
   10920                             {
   10921                                 ios.width(0);
   10922                                 {
   10923                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10924                                     std::string ex(str, iter.base());
   10925                                     assert(ex == "nan");
   10926                                     assert(ios.width() == 0);
   10927                                 }
   10928                                 ios.width(25);
   10929                                 left(ios);
   10930                                 {
   10931                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10932                                     std::string ex(str, iter.base());
   10933                                     assert(ex == "nan**********************");
   10934                                     assert(ios.width() == 0);
   10935                                 }
   10936                                 ios.width(25);
   10937                                 right(ios);
   10938                                 {
   10939                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10940                                     std::string ex(str, iter.base());
   10941                                     assert(ex == "**********************nan");
   10942                                     assert(ios.width() == 0);
   10943                                 }
   10944                                 ios.width(25);
   10945                                 internal(ios);
   10946                                 {
   10947                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10948                                     std::string ex(str, iter.base());
   10949                                     assert(ex == "**********************nan");
   10950                                     assert(ios.width() == 0);
   10951                                 }
   10952                             }
   10953                         }
   10954                         showpoint(ios);
   10955                         {
   10956                             ios.imbue(lc);
   10957                             {
   10958                                 ios.width(0);
   10959                                 {
   10960                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10961                                     std::string ex(str, iter.base());
   10962                                     assert(ex == "nan");
   10963                                     assert(ios.width() == 0);
   10964                                 }
   10965                                 ios.width(25);
   10966                                 left(ios);
   10967                                 {
   10968                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10969                                     std::string ex(str, iter.base());
   10970                                     assert(ex == "nan**********************");
   10971                                     assert(ios.width() == 0);
   10972                                 }
   10973                                 ios.width(25);
   10974                                 right(ios);
   10975                                 {
   10976                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10977                                     std::string ex(str, iter.base());
   10978                                     assert(ex == "**********************nan");
   10979                                     assert(ios.width() == 0);
   10980                                 }
   10981                                 ios.width(25);
   10982                                 internal(ios);
   10983                                 {
   10984                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10985                                     std::string ex(str, iter.base());
   10986                                     assert(ex == "**********************nan");
   10987                                     assert(ios.width() == 0);
   10988                                 }
   10989                             }
   10990                             ios.imbue(lg);
   10991                             {
   10992                                 ios.width(0);
   10993                                 {
   10994                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10995                                     std::string ex(str, iter.base());
   10996                                     assert(ex == "nan");
   10997                                     assert(ios.width() == 0);
   10998                                 }
   10999                                 ios.width(25);
   11000                                 left(ios);
   11001                                 {
   11002                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11003                                     std::string ex(str, iter.base());
   11004                                     assert(ex == "nan**********************");
   11005                                     assert(ios.width() == 0);
   11006                                 }
   11007                                 ios.width(25);
   11008                                 right(ios);
   11009                                 {
   11010                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11011                                     std::string ex(str, iter.base());
   11012                                     assert(ex == "**********************nan");
   11013                                     assert(ios.width() == 0);
   11014                                 }
   11015                                 ios.width(25);
   11016                                 internal(ios);
   11017                                 {
   11018                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11019                                     std::string ex(str, iter.base());
   11020                                     assert(ex == "**********************nan");
   11021                                     assert(ios.width() == 0);
   11022                                 }
   11023                             }
   11024                         }
   11025                     }
   11026                 }
   11027                 uppercase(ios);
   11028                 {
   11029                     noshowpos(ios);
   11030                     {
   11031                         noshowpoint(ios);
   11032                         {
   11033                             ios.imbue(lc);
   11034                             {
   11035                                 ios.width(0);
   11036                                 {
   11037                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11038                                     std::string ex(str, iter.base());
   11039                                     assert(ex == "NAN");
   11040                                     assert(ios.width() == 0);
   11041                                 }
   11042                                 ios.width(25);
   11043                                 left(ios);
   11044                                 {
   11045                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11046                                     std::string ex(str, iter.base());
   11047                                     assert(ex == "NAN**********************");
   11048                                     assert(ios.width() == 0);
   11049                                 }
   11050                                 ios.width(25);
   11051                                 right(ios);
   11052                                 {
   11053                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11054                                     std::string ex(str, iter.base());
   11055                                     assert(ex == "**********************NAN");
   11056                                     assert(ios.width() == 0);
   11057                                 }
   11058                                 ios.width(25);
   11059                                 internal(ios);
   11060                                 {
   11061                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11062                                     std::string ex(str, iter.base());
   11063                                     assert(ex == "**********************NAN");
   11064                                     assert(ios.width() == 0);
   11065                                 }
   11066                             }
   11067                             ios.imbue(lg);
   11068                             {
   11069                                 ios.width(0);
   11070                                 {
   11071                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11072                                     std::string ex(str, iter.base());
   11073                                     assert(ex == "NAN");
   11074                                     assert(ios.width() == 0);
   11075                                 }
   11076                                 ios.width(25);
   11077                                 left(ios);
   11078                                 {
   11079                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11080                                     std::string ex(str, iter.base());
   11081                                     assert(ex == "NAN**********************");
   11082                                     assert(ios.width() == 0);
   11083                                 }
   11084                                 ios.width(25);
   11085                                 right(ios);
   11086                                 {
   11087                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11088                                     std::string ex(str, iter.base());
   11089                                     assert(ex == "**********************NAN");
   11090                                     assert(ios.width() == 0);
   11091                                 }
   11092                                 ios.width(25);
   11093                                 internal(ios);
   11094                                 {
   11095                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11096                                     std::string ex(str, iter.base());
   11097                                     assert(ex == "**********************NAN");
   11098                                     assert(ios.width() == 0);
   11099                                 }
   11100                             }
   11101                         }
   11102                         showpoint(ios);
   11103                         {
   11104                             ios.imbue(lc);
   11105                             {
   11106                                 ios.width(0);
   11107                                 {
   11108                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11109                                     std::string ex(str, iter.base());
   11110                                     assert(ex == "NAN");
   11111                                     assert(ios.width() == 0);
   11112                                 }
   11113                                 ios.width(25);
   11114                                 left(ios);
   11115                                 {
   11116                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11117                                     std::string ex(str, iter.base());
   11118                                     assert(ex == "NAN**********************");
   11119                                     assert(ios.width() == 0);
   11120                                 }
   11121                                 ios.width(25);
   11122                                 right(ios);
   11123                                 {
   11124                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11125                                     std::string ex(str, iter.base());
   11126                                     assert(ex == "**********************NAN");
   11127                                     assert(ios.width() == 0);
   11128                                 }
   11129                                 ios.width(25);
   11130                                 internal(ios);
   11131                                 {
   11132                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11133                                     std::string ex(str, iter.base());
   11134                                     assert(ex == "**********************NAN");
   11135                                     assert(ios.width() == 0);
   11136                                 }
   11137                             }
   11138                             ios.imbue(lg);
   11139                             {
   11140                                 ios.width(0);
   11141                                 {
   11142                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11143                                     std::string ex(str, iter.base());
   11144                                     assert(ex == "NAN");
   11145                                     assert(ios.width() == 0);
   11146                                 }
   11147                                 ios.width(25);
   11148                                 left(ios);
   11149                                 {
   11150                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11151                                     std::string ex(str, iter.base());
   11152                                     assert(ex == "NAN**********************");
   11153                                     assert(ios.width() == 0);
   11154                                 }
   11155                                 ios.width(25);
   11156                                 right(ios);
   11157                                 {
   11158                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11159                                     std::string ex(str, iter.base());
   11160                                     assert(ex == "**********************NAN");
   11161                                     assert(ios.width() == 0);
   11162                                 }
   11163                                 ios.width(25);
   11164                                 internal(ios);
   11165                                 {
   11166                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11167                                     std::string ex(str, iter.base());
   11168                                     assert(ex == "**********************NAN");
   11169                                     assert(ios.width() == 0);
   11170                                 }
   11171                             }
   11172                         }
   11173                     }
   11174                     showpos(ios);
   11175                     {
   11176                         noshowpoint(ios);
   11177                         {
   11178                             ios.imbue(lc);
   11179                             {
   11180                                 ios.width(0);
   11181                                 {
   11182                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11183                                     std::string ex(str, iter.base());
   11184                                     assert(ex == "NAN");
   11185                                     assert(ios.width() == 0);
   11186                                 }
   11187                                 ios.width(25);
   11188                                 left(ios);
   11189                                 {
   11190                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11191                                     std::string ex(str, iter.base());
   11192                                     assert(ex == "NAN**********************");
   11193                                     assert(ios.width() == 0);
   11194                                 }
   11195                                 ios.width(25);
   11196                                 right(ios);
   11197                                 {
   11198                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11199                                     std::string ex(str, iter.base());
   11200                                     assert(ex == "**********************NAN");
   11201                                     assert(ios.width() == 0);
   11202                                 }
   11203                                 ios.width(25);
   11204                                 internal(ios);
   11205                                 {
   11206                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11207                                     std::string ex(str, iter.base());
   11208                                     assert(ex == "**********************NAN");
   11209                                     assert(ios.width() == 0);
   11210                                 }
   11211                             }
   11212                             ios.imbue(lg);
   11213                             {
   11214                                 ios.width(0);
   11215                                 {
   11216                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11217                                     std::string ex(str, iter.base());
   11218                                     assert(ex == "NAN");
   11219                                     assert(ios.width() == 0);
   11220                                 }
   11221                                 ios.width(25);
   11222                                 left(ios);
   11223                                 {
   11224                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11225                                     std::string ex(str, iter.base());
   11226                                     assert(ex == "NAN**********************");
   11227                                     assert(ios.width() == 0);
   11228                                 }
   11229                                 ios.width(25);
   11230                                 right(ios);
   11231                                 {
   11232                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11233                                     std::string ex(str, iter.base());
   11234                                     assert(ex == "**********************NAN");
   11235                                     assert(ios.width() == 0);
   11236                                 }
   11237                                 ios.width(25);
   11238                                 internal(ios);
   11239                                 {
   11240                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11241                                     std::string ex(str, iter.base());
   11242                                     assert(ex == "**********************NAN");
   11243                                     assert(ios.width() == 0);
   11244                                 }
   11245                             }
   11246                         }
   11247                         showpoint(ios);
   11248                         {
   11249                             ios.imbue(lc);
   11250                             {
   11251                                 ios.width(0);
   11252                                 {
   11253                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11254                                     std::string ex(str, iter.base());
   11255                                     assert(ex == "NAN");
   11256                                     assert(ios.width() == 0);
   11257                                 }
   11258                                 ios.width(25);
   11259                                 left(ios);
   11260                                 {
   11261                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11262                                     std::string ex(str, iter.base());
   11263                                     assert(ex == "NAN**********************");
   11264                                     assert(ios.width() == 0);
   11265                                 }
   11266                                 ios.width(25);
   11267                                 right(ios);
   11268                                 {
   11269                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11270                                     std::string ex(str, iter.base());
   11271                                     assert(ex == "**********************NAN");
   11272                                     assert(ios.width() == 0);
   11273                                 }
   11274                                 ios.width(25);
   11275                                 internal(ios);
   11276                                 {
   11277                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11278                                     std::string ex(str, iter.base());
   11279                                     assert(ex == "**********************NAN");
   11280                                     assert(ios.width() == 0);
   11281                                 }
   11282                             }
   11283                             ios.imbue(lg);
   11284                             {
   11285                                 ios.width(0);
   11286                                 {
   11287                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11288                                     std::string ex(str, iter.base());
   11289                                     assert(ex == "NAN");
   11290                                     assert(ios.width() == 0);
   11291                                 }
   11292                                 ios.width(25);
   11293                                 left(ios);
   11294                                 {
   11295                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11296                                     std::string ex(str, iter.base());
   11297                                     assert(ex == "NAN**********************");
   11298                                     assert(ios.width() == 0);
   11299                                 }
   11300                                 ios.width(25);
   11301                                 right(ios);
   11302                                 {
   11303                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11304                                     std::string ex(str, iter.base());
   11305                                     assert(ex == "**********************NAN");
   11306                                     assert(ios.width() == 0);
   11307                                 }
   11308                                 ios.width(25);
   11309                                 internal(ios);
   11310                                 {
   11311                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11312                                     std::string ex(str, iter.base());
   11313                                     assert(ex == "**********************NAN");
   11314                                     assert(ios.width() == 0);
   11315                                 }
   11316                             }
   11317                         }
   11318                     }
   11319                 }
   11320             }
   11321             ios.precision(1);
   11322             {}
   11323             ios.precision(6);
   11324             {}
   11325             ios.precision(16);
   11326             {}
   11327             ios.precision(60);
   11328             {}
   11329         }
   11330     }
   11331 }
   11332 
   11333 void test6()
   11334 {
   11335     char str[200];
   11336     output_iterator<char*> iter;
   11337     std::locale lc = std::locale::classic();
   11338     std::locale lg(lc, new my_numpunct);
   11339     const my_facet f(1);
   11340     {
   11341         long double v = +0.;
   11342         std::ios ios(0);
   11343         fixed(ios);
   11344         // %f
   11345         {
   11346             ios.precision(0);
   11347             {
   11348                 nouppercase(ios);
   11349                 {
   11350                     noshowpos(ios);
   11351                     {
   11352                         noshowpoint(ios);
   11353                         {
   11354                             ios.imbue(lc);
   11355                             {
   11356                                 ios.width(0);
   11357                                 {
   11358                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11359                                     std::string ex(str, iter.base());
   11360                                     assert(ex == "0");
   11361                                     assert(ios.width() == 0);
   11362                                 }
   11363                                 ios.width(25);
   11364                                 left(ios);
   11365                                 {
   11366                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11367                                     std::string ex(str, iter.base());
   11368                                     assert(ex == "0************************");
   11369                                     assert(ios.width() == 0);
   11370                                 }
   11371                                 ios.width(25);
   11372                                 right(ios);
   11373                                 {
   11374                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11375                                     std::string ex(str, iter.base());
   11376                                     assert(ex == "************************0");
   11377                                     assert(ios.width() == 0);
   11378                                 }
   11379                                 ios.width(25);
   11380                                 internal(ios);
   11381                                 {
   11382                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11383                                     std::string ex(str, iter.base());
   11384                                     assert(ex == "************************0");
   11385                                     assert(ios.width() == 0);
   11386                                 }
   11387                             }
   11388                             ios.imbue(lg);
   11389                             {
   11390                                 ios.width(0);
   11391                                 {
   11392                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11393                                     std::string ex(str, iter.base());
   11394                                     assert(ex == "0");
   11395                                     assert(ios.width() == 0);
   11396                                 }
   11397                                 ios.width(25);
   11398                                 left(ios);
   11399                                 {
   11400                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11401                                     std::string ex(str, iter.base());
   11402                                     assert(ex == "0************************");
   11403                                     assert(ios.width() == 0);
   11404                                 }
   11405                                 ios.width(25);
   11406                                 right(ios);
   11407                                 {
   11408                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11409                                     std::string ex(str, iter.base());
   11410                                     assert(ex == "************************0");
   11411                                     assert(ios.width() == 0);
   11412                                 }
   11413                                 ios.width(25);
   11414                                 internal(ios);
   11415                                 {
   11416                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11417                                     std::string ex(str, iter.base());
   11418                                     assert(ex == "************************0");
   11419                                     assert(ios.width() == 0);
   11420                                 }
   11421                             }
   11422                         }
   11423                         showpoint(ios);
   11424                         {
   11425                             ios.imbue(lc);
   11426                             {
   11427                                 ios.width(0);
   11428                                 {
   11429                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11430                                     std::string ex(str, iter.base());
   11431                                     assert(ex == "0.");
   11432                                     assert(ios.width() == 0);
   11433                                 }
   11434                                 ios.width(25);
   11435                                 left(ios);
   11436                                 {
   11437                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11438                                     std::string ex(str, iter.base());
   11439                                     assert(ex == "0.***********************");
   11440                                     assert(ios.width() == 0);
   11441                                 }
   11442                                 ios.width(25);
   11443                                 right(ios);
   11444                                 {
   11445                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11446                                     std::string ex(str, iter.base());
   11447                                     assert(ex == "***********************0.");
   11448                                     assert(ios.width() == 0);
   11449                                 }
   11450                                 ios.width(25);
   11451                                 internal(ios);
   11452                                 {
   11453                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11454                                     std::string ex(str, iter.base());
   11455                                     assert(ex == "***********************0.");
   11456                                     assert(ios.width() == 0);
   11457                                 }
   11458                             }
   11459                             ios.imbue(lg);
   11460                             {
   11461                                 ios.width(0);
   11462                                 {
   11463                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11464                                     std::string ex(str, iter.base());
   11465                                     assert(ex == "0;");
   11466                                     assert(ios.width() == 0);
   11467                                 }
   11468                                 ios.width(25);
   11469                                 left(ios);
   11470                                 {
   11471                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11472                                     std::string ex(str, iter.base());
   11473                                     assert(ex == "0;***********************");
   11474                                     assert(ios.width() == 0);
   11475                                 }
   11476                                 ios.width(25);
   11477                                 right(ios);
   11478                                 {
   11479                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11480                                     std::string ex(str, iter.base());
   11481                                     assert(ex == "***********************0;");
   11482                                     assert(ios.width() == 0);
   11483                                 }
   11484                                 ios.width(25);
   11485                                 internal(ios);
   11486                                 {
   11487                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11488                                     std::string ex(str, iter.base());
   11489                                     assert(ex == "***********************0;");
   11490                                     assert(ios.width() == 0);
   11491                                 }
   11492                             }
   11493                         }
   11494                     }
   11495                     showpos(ios);
   11496                     {
   11497                         noshowpoint(ios);
   11498                         {
   11499                             ios.imbue(lc);
   11500                             {
   11501                                 ios.width(0);
   11502                                 {
   11503                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11504                                     std::string ex(str, iter.base());
   11505                                     assert(ex == "+0");
   11506                                     assert(ios.width() == 0);
   11507                                 }
   11508                                 ios.width(25);
   11509                                 left(ios);
   11510                                 {
   11511                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11512                                     std::string ex(str, iter.base());
   11513                                     assert(ex == "+0***********************");
   11514                                     assert(ios.width() == 0);
   11515                                 }
   11516                                 ios.width(25);
   11517                                 right(ios);
   11518                                 {
   11519                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11520                                     std::string ex(str, iter.base());
   11521                                     assert(ex == "***********************+0");
   11522                                     assert(ios.width() == 0);
   11523                                 }
   11524                                 ios.width(25);
   11525                                 internal(ios);
   11526                                 {
   11527                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11528                                     std::string ex(str, iter.base());
   11529                                     assert(ex == "+***********************0");
   11530                                     assert(ios.width() == 0);
   11531                                 }
   11532                             }
   11533                             ios.imbue(lg);
   11534                             {
   11535                                 ios.width(0);
   11536                                 {
   11537                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11538                                     std::string ex(str, iter.base());
   11539                                     assert(ex == "+0");
   11540                                     assert(ios.width() == 0);
   11541                                 }
   11542                                 ios.width(25);
   11543                                 left(ios);
   11544                                 {
   11545                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11546                                     std::string ex(str, iter.base());
   11547                                     assert(ex == "+0***********************");
   11548                                     assert(ios.width() == 0);
   11549                                 }
   11550                                 ios.width(25);
   11551                                 right(ios);
   11552                                 {
   11553                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11554                                     std::string ex(str, iter.base());
   11555                                     assert(ex == "***********************+0");
   11556                                     assert(ios.width() == 0);
   11557                                 }
   11558                                 ios.width(25);
   11559                                 internal(ios);
   11560                                 {
   11561                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11562                                     std::string ex(str, iter.base());
   11563                                     assert(ex == "+***********************0");
   11564                                     assert(ios.width() == 0);
   11565                                 }
   11566                             }
   11567                         }
   11568                         showpoint(ios);
   11569                         {
   11570                             ios.imbue(lc);
   11571                             {
   11572                                 ios.width(0);
   11573                                 {
   11574                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11575                                     std::string ex(str, iter.base());
   11576                                     assert(ex == "+0.");
   11577                                     assert(ios.width() == 0);
   11578                                 }
   11579                                 ios.width(25);
   11580                                 left(ios);
   11581                                 {
   11582                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11583                                     std::string ex(str, iter.base());
   11584                                     assert(ex == "+0.**********************");
   11585                                     assert(ios.width() == 0);
   11586                                 }
   11587                                 ios.width(25);
   11588                                 right(ios);
   11589                                 {
   11590                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11591                                     std::string ex(str, iter.base());
   11592                                     assert(ex == "**********************+0.");
   11593                                     assert(ios.width() == 0);
   11594                                 }
   11595                                 ios.width(25);
   11596                                 internal(ios);
   11597                                 {
   11598                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11599                                     std::string ex(str, iter.base());
   11600                                     assert(ex == "+**********************0.");
   11601                                     assert(ios.width() == 0);
   11602                                 }
   11603                             }
   11604                             ios.imbue(lg);
   11605                             {
   11606                                 ios.width(0);
   11607                                 {
   11608                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11609                                     std::string ex(str, iter.base());
   11610                                     assert(ex == "+0;");
   11611                                     assert(ios.width() == 0);
   11612                                 }
   11613                                 ios.width(25);
   11614                                 left(ios);
   11615                                 {
   11616                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11617                                     std::string ex(str, iter.base());
   11618                                     assert(ex == "+0;**********************");
   11619                                     assert(ios.width() == 0);
   11620                                 }
   11621                                 ios.width(25);
   11622                                 right(ios);
   11623                                 {
   11624                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11625                                     std::string ex(str, iter.base());
   11626                                     assert(ex == "**********************+0;");
   11627                                     assert(ios.width() == 0);
   11628                                 }
   11629                                 ios.width(25);
   11630                                 internal(ios);
   11631                                 {
   11632                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11633                                     std::string ex(str, iter.base());
   11634                                     assert(ex == "+**********************0;");
   11635                                     assert(ios.width() == 0);
   11636                                 }
   11637                             }
   11638                         }
   11639                     }
   11640                 }
   11641                 uppercase(ios);
   11642                 {
   11643                     noshowpos(ios);
   11644                     {
   11645                         noshowpoint(ios);
   11646                         {
   11647                             ios.imbue(lc);
   11648                             {
   11649                                 ios.width(0);
   11650                                 {
   11651                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11652                                     std::string ex(str, iter.base());
   11653                                     assert(ex == "0");
   11654                                     assert(ios.width() == 0);
   11655                                 }
   11656                                 ios.width(25);
   11657                                 left(ios);
   11658                                 {
   11659                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11660                                     std::string ex(str, iter.base());
   11661                                     assert(ex == "0************************");
   11662                                     assert(ios.width() == 0);
   11663                                 }
   11664                                 ios.width(25);
   11665                                 right(ios);
   11666                                 {
   11667                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11668                                     std::string ex(str, iter.base());
   11669                                     assert(ex == "************************0");
   11670                                     assert(ios.width() == 0);
   11671                                 }
   11672                                 ios.width(25);
   11673                                 internal(ios);
   11674                                 {
   11675                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11676                                     std::string ex(str, iter.base());
   11677                                     assert(ex == "************************0");
   11678                                     assert(ios.width() == 0);
   11679                                 }
   11680                             }
   11681                             ios.imbue(lg);
   11682                             {
   11683                                 ios.width(0);
   11684                                 {
   11685                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11686                                     std::string ex(str, iter.base());
   11687                                     assert(ex == "0");
   11688                                     assert(ios.width() == 0);
   11689                                 }
   11690                                 ios.width(25);
   11691                                 left(ios);
   11692                                 {
   11693                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11694                                     std::string ex(str, iter.base());
   11695                                     assert(ex == "0************************");
   11696                                     assert(ios.width() == 0);
   11697                                 }
   11698                                 ios.width(25);
   11699                                 right(ios);
   11700                                 {
   11701                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11702                                     std::string ex(str, iter.base());
   11703                                     assert(ex == "************************0");
   11704                                     assert(ios.width() == 0);
   11705                                 }
   11706                                 ios.width(25);
   11707                                 internal(ios);
   11708                                 {
   11709                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11710                                     std::string ex(str, iter.base());
   11711                                     assert(ex == "************************0");
   11712                                     assert(ios.width() == 0);
   11713                                 }
   11714                             }
   11715                         }
   11716                         showpoint(ios);
   11717                         {
   11718                             ios.imbue(lc);
   11719                             {
   11720                                 ios.width(0);
   11721                                 {
   11722                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11723                                     std::string ex(str, iter.base());
   11724                                     assert(ex == "0.");
   11725                                     assert(ios.width() == 0);
   11726                                 }
   11727                                 ios.width(25);
   11728                                 left(ios);
   11729                                 {
   11730                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11731                                     std::string ex(str, iter.base());
   11732                                     assert(ex == "0.***********************");
   11733                                     assert(ios.width() == 0);
   11734                                 }
   11735                                 ios.width(25);
   11736                                 right(ios);
   11737                                 {
   11738                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11739                                     std::string ex(str, iter.base());
   11740                                     assert(ex == "***********************0.");
   11741                                     assert(ios.width() == 0);
   11742                                 }
   11743                                 ios.width(25);
   11744                                 internal(ios);
   11745                                 {
   11746                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11747                                     std::string ex(str, iter.base());
   11748                                     assert(ex == "***********************0.");
   11749                                     assert(ios.width() == 0);
   11750                                 }
   11751                             }
   11752                             ios.imbue(lg);
   11753                             {
   11754                                 ios.width(0);
   11755                                 {
   11756                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11757                                     std::string ex(str, iter.base());
   11758                                     assert(ex == "0;");
   11759                                     assert(ios.width() == 0);
   11760                                 }
   11761                                 ios.width(25);
   11762                                 left(ios);
   11763                                 {
   11764                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11765                                     std::string ex(str, iter.base());
   11766                                     assert(ex == "0;***********************");
   11767                                     assert(ios.width() == 0);
   11768                                 }
   11769                                 ios.width(25);
   11770                                 right(ios);
   11771                                 {
   11772                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11773                                     std::string ex(str, iter.base());
   11774                                     assert(ex == "***********************0;");
   11775                                     assert(ios.width() == 0);
   11776                                 }
   11777                                 ios.width(25);
   11778                                 internal(ios);
   11779                                 {
   11780                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11781                                     std::string ex(str, iter.base());
   11782                                     assert(ex == "***********************0;");
   11783                                     assert(ios.width() == 0);
   11784                                 }
   11785                             }
   11786                         }
   11787                     }
   11788                     showpos(ios);
   11789                     {
   11790                         noshowpoint(ios);
   11791                         {
   11792                             ios.imbue(lc);
   11793                             {
   11794                                 ios.width(0);
   11795                                 {
   11796                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11797                                     std::string ex(str, iter.base());
   11798                                     assert(ex == "+0");
   11799                                     assert(ios.width() == 0);
   11800                                 }
   11801                                 ios.width(25);
   11802                                 left(ios);
   11803                                 {
   11804                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11805                                     std::string ex(str, iter.base());
   11806                                     assert(ex == "+0***********************");
   11807                                     assert(ios.width() == 0);
   11808                                 }
   11809                                 ios.width(25);
   11810                                 right(ios);
   11811                                 {
   11812                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11813                                     std::string ex(str, iter.base());
   11814                                     assert(ex == "***********************+0");
   11815                                     assert(ios.width() == 0);
   11816                                 }
   11817                                 ios.width(25);
   11818                                 internal(ios);
   11819                                 {
   11820                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11821                                     std::string ex(str, iter.base());
   11822                                     assert(ex == "+***********************0");
   11823                                     assert(ios.width() == 0);
   11824                                 }
   11825                             }
   11826                             ios.imbue(lg);
   11827                             {
   11828                                 ios.width(0);
   11829                                 {
   11830                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11831                                     std::string ex(str, iter.base());
   11832                                     assert(ex == "+0");
   11833                                     assert(ios.width() == 0);
   11834                                 }
   11835                                 ios.width(25);
   11836                                 left(ios);
   11837                                 {
   11838                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11839                                     std::string ex(str, iter.base());
   11840                                     assert(ex == "+0***********************");
   11841                                     assert(ios.width() == 0);
   11842                                 }
   11843                                 ios.width(25);
   11844                                 right(ios);
   11845                                 {
   11846                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11847                                     std::string ex(str, iter.base());
   11848                                     assert(ex == "***********************+0");
   11849                                     assert(ios.width() == 0);
   11850                                 }
   11851                                 ios.width(25);
   11852                                 internal(ios);
   11853                                 {
   11854                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11855                                     std::string ex(str, iter.base());
   11856                                     assert(ex == "+***********************0");
   11857                                     assert(ios.width() == 0);
   11858                                 }
   11859                             }
   11860                         }
   11861                         showpoint(ios);
   11862                         {
   11863                             ios.imbue(lc);
   11864                             {
   11865                                 ios.width(0);
   11866                                 {
   11867                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11868                                     std::string ex(str, iter.base());
   11869                                     assert(ex == "+0.");
   11870                                     assert(ios.width() == 0);
   11871                                 }
   11872                                 ios.width(25);
   11873                                 left(ios);
   11874                                 {
   11875                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11876                                     std::string ex(str, iter.base());
   11877                                     assert(ex == "+0.**********************");
   11878                                     assert(ios.width() == 0);
   11879                                 }
   11880                                 ios.width(25);
   11881                                 right(ios);
   11882                                 {
   11883                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11884                                     std::string ex(str, iter.base());
   11885                                     assert(ex == "**********************+0.");
   11886                                     assert(ios.width() == 0);
   11887                                 }
   11888                                 ios.width(25);
   11889                                 internal(ios);
   11890                                 {
   11891                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11892                                     std::string ex(str, iter.base());
   11893                                     assert(ex == "+**********************0.");
   11894                                     assert(ios.width() == 0);
   11895                                 }
   11896                             }
   11897                             ios.imbue(lg);
   11898                             {
   11899                                 ios.width(0);
   11900                                 {
   11901                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11902                                     std::string ex(str, iter.base());
   11903                                     assert(ex == "+0;");
   11904                                     assert(ios.width() == 0);
   11905                                 }
   11906                                 ios.width(25);
   11907                                 left(ios);
   11908                                 {
   11909                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11910                                     std::string ex(str, iter.base());
   11911                                     assert(ex == "+0;**********************");
   11912                                     assert(ios.width() == 0);
   11913                                 }
   11914                                 ios.width(25);
   11915                                 right(ios);
   11916                                 {
   11917                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11918                                     std::string ex(str, iter.base());
   11919                                     assert(ex == "**********************+0;");
   11920                                     assert(ios.width() == 0);
   11921                                 }
   11922                                 ios.width(25);
   11923                                 internal(ios);
   11924                                 {
   11925                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11926                                     std::string ex(str, iter.base());
   11927                                     assert(ex == "+**********************0;");
   11928                                     assert(ios.width() == 0);
   11929                                 }
   11930                             }
   11931                         }
   11932                     }
   11933                 }
   11934             }
   11935             ios.precision(1);
   11936             {
   11937                 nouppercase(ios);
   11938                 {
   11939                     noshowpos(ios);
   11940                     {
   11941                         noshowpoint(ios);
   11942                         {
   11943                             ios.imbue(lc);
   11944                             {
   11945                                 ios.width(0);
   11946                                 {
   11947                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11948                                     std::string ex(str, iter.base());
   11949                                     assert(ex == "0.0");
   11950                                     assert(ios.width() == 0);
   11951                                 }
   11952                                 ios.width(25);
   11953                                 left(ios);
   11954                                 {
   11955                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11956                                     std::string ex(str, iter.base());
   11957                                     assert(ex == "0.0**********************");
   11958                                     assert(ios.width() == 0);
   11959                                 }
   11960                                 ios.width(25);
   11961                                 right(ios);
   11962                                 {
   11963                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11964                                     std::string ex(str, iter.base());
   11965                                     assert(ex == "**********************0.0");
   11966                                     assert(ios.width() == 0);
   11967                                 }
   11968                                 ios.width(25);
   11969                                 internal(ios);
   11970                                 {
   11971                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11972                                     std::string ex(str, iter.base());
   11973                                     assert(ex == "**********************0.0");
   11974                                     assert(ios.width() == 0);
   11975                                 }
   11976                             }
   11977                             ios.imbue(lg);
   11978                             {
   11979                                 ios.width(0);
   11980                                 {
   11981                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11982                                     std::string ex(str, iter.base());
   11983                                     assert(ex == "0;0");
   11984                                     assert(ios.width() == 0);
   11985                                 }
   11986                                 ios.width(25);
   11987                                 left(ios);
   11988                                 {
   11989                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11990                                     std::string ex(str, iter.base());
   11991                                     assert(ex == "0;0**********************");
   11992                                     assert(ios.width() == 0);
   11993                                 }
   11994                                 ios.width(25);
   11995                                 right(ios);
   11996                                 {
   11997                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11998                                     std::string ex(str, iter.base());
   11999                                     assert(ex == "**********************0;0");
   12000                                     assert(ios.width() == 0);
   12001                                 }
   12002                                 ios.width(25);
   12003                                 internal(ios);
   12004                                 {
   12005                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12006                                     std::string ex(str, iter.base());
   12007                                     assert(ex == "**********************0;0");
   12008                                     assert(ios.width() == 0);
   12009                                 }
   12010                             }
   12011                         }
   12012                         showpoint(ios);
   12013                         {
   12014                             ios.imbue(lc);
   12015                             {
   12016                                 ios.width(0);
   12017                                 {
   12018                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12019                                     std::string ex(str, iter.base());
   12020                                     assert(ex == "0.0");
   12021                                     assert(ios.width() == 0);
   12022                                 }
   12023                                 ios.width(25);
   12024                                 left(ios);
   12025                                 {
   12026                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12027                                     std::string ex(str, iter.base());
   12028                                     assert(ex == "0.0**********************");
   12029                                     assert(ios.width() == 0);
   12030                                 }
   12031                                 ios.width(25);
   12032                                 right(ios);
   12033                                 {
   12034                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12035                                     std::string ex(str, iter.base());
   12036                                     assert(ex == "**********************0.0");
   12037                                     assert(ios.width() == 0);
   12038                                 }
   12039                                 ios.width(25);
   12040                                 internal(ios);
   12041                                 {
   12042                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12043                                     std::string ex(str, iter.base());
   12044                                     assert(ex == "**********************0.0");
   12045                                     assert(ios.width() == 0);
   12046                                 }
   12047                             }
   12048                             ios.imbue(lg);
   12049                             {
   12050                                 ios.width(0);
   12051                                 {
   12052                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12053                                     std::string ex(str, iter.base());
   12054                                     assert(ex == "0;0");
   12055                                     assert(ios.width() == 0);
   12056                                 }
   12057                                 ios.width(25);
   12058                                 left(ios);
   12059                                 {
   12060                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12061                                     std::string ex(str, iter.base());
   12062                                     assert(ex == "0;0**********************");
   12063                                     assert(ios.width() == 0);
   12064                                 }
   12065                                 ios.width(25);
   12066                                 right(ios);
   12067                                 {
   12068                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12069                                     std::string ex(str, iter.base());
   12070                                     assert(ex == "**********************0;0");
   12071                                     assert(ios.width() == 0);
   12072                                 }
   12073                                 ios.width(25);
   12074                                 internal(ios);
   12075                                 {
   12076                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12077                                     std::string ex(str, iter.base());
   12078                                     assert(ex == "**********************0;0");
   12079                                     assert(ios.width() == 0);
   12080                                 }
   12081                             }
   12082                         }
   12083                     }
   12084                     showpos(ios);
   12085                     {
   12086                         noshowpoint(ios);
   12087                         {
   12088                             ios.imbue(lc);
   12089                             {
   12090                                 ios.width(0);
   12091                                 {
   12092                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12093                                     std::string ex(str, iter.base());
   12094                                     assert(ex == "+0.0");
   12095                                     assert(ios.width() == 0);
   12096                                 }
   12097                                 ios.width(25);
   12098                                 left(ios);
   12099                                 {
   12100                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12101                                     std::string ex(str, iter.base());
   12102                                     assert(ex == "+0.0*********************");
   12103                                     assert(ios.width() == 0);
   12104                                 }
   12105                                 ios.width(25);
   12106                                 right(ios);
   12107                                 {
   12108                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12109                                     std::string ex(str, iter.base());
   12110                                     assert(ex == "*********************+0.0");
   12111                                     assert(ios.width() == 0);
   12112                                 }
   12113                                 ios.width(25);
   12114                                 internal(ios);
   12115                                 {
   12116                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12117                                     std::string ex(str, iter.base());
   12118                                     assert(ex == "+*********************0.0");
   12119                                     assert(ios.width() == 0);
   12120                                 }
   12121                             }
   12122                             ios.imbue(lg);
   12123                             {
   12124                                 ios.width(0);
   12125                                 {
   12126                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12127                                     std::string ex(str, iter.base());
   12128                                     assert(ex == "+0;0");
   12129                                     assert(ios.width() == 0);
   12130                                 }
   12131                                 ios.width(25);
   12132                                 left(ios);
   12133                                 {
   12134                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12135                                     std::string ex(str, iter.base());
   12136                                     assert(ex == "+0;0*********************");
   12137                                     assert(ios.width() == 0);
   12138                                 }
   12139                                 ios.width(25);
   12140                                 right(ios);
   12141                                 {
   12142                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12143                                     std::string ex(str, iter.base());
   12144                                     assert(ex == "*********************+0;0");
   12145                                     assert(ios.width() == 0);
   12146                                 }
   12147                                 ios.width(25);
   12148                                 internal(ios);
   12149                                 {
   12150                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12151                                     std::string ex(str, iter.base());
   12152                                     assert(ex == "+*********************0;0");
   12153                                     assert(ios.width() == 0);
   12154                                 }
   12155                             }
   12156                         }
   12157                         showpoint(ios);
   12158                         {
   12159                             ios.imbue(lc);
   12160                             {
   12161                                 ios.width(0);
   12162                                 {
   12163                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12164                                     std::string ex(str, iter.base());
   12165                                     assert(ex == "+0.0");
   12166                                     assert(ios.width() == 0);
   12167                                 }
   12168                                 ios.width(25);
   12169                                 left(ios);
   12170                                 {
   12171                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12172                                     std::string ex(str, iter.base());
   12173                                     assert(ex == "+0.0*********************");
   12174                                     assert(ios.width() == 0);
   12175                                 }
   12176                                 ios.width(25);
   12177                                 right(ios);
   12178                                 {
   12179                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12180                                     std::string ex(str, iter.base());
   12181                                     assert(ex == "*********************+0.0");
   12182                                     assert(ios.width() == 0);
   12183                                 }
   12184                                 ios.width(25);
   12185                                 internal(ios);
   12186                                 {
   12187                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12188                                     std::string ex(str, iter.base());
   12189                                     assert(ex == "+*********************0.0");
   12190                                     assert(ios.width() == 0);
   12191                                 }
   12192                             }
   12193                             ios.imbue(lg);
   12194                             {
   12195                                 ios.width(0);
   12196                                 {
   12197                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12198                                     std::string ex(str, iter.base());
   12199                                     assert(ex == "+0;0");
   12200                                     assert(ios.width() == 0);
   12201                                 }
   12202                                 ios.width(25);
   12203                                 left(ios);
   12204                                 {
   12205                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12206                                     std::string ex(str, iter.base());
   12207                                     assert(ex == "+0;0*********************");
   12208                                     assert(ios.width() == 0);
   12209                                 }
   12210                                 ios.width(25);
   12211                                 right(ios);
   12212                                 {
   12213                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12214                                     std::string ex(str, iter.base());
   12215                                     assert(ex == "*********************+0;0");
   12216                                     assert(ios.width() == 0);
   12217                                 }
   12218                                 ios.width(25);
   12219                                 internal(ios);
   12220                                 {
   12221                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12222                                     std::string ex(str, iter.base());
   12223                                     assert(ex == "+*********************0;0");
   12224                                     assert(ios.width() == 0);
   12225                                 }
   12226                             }
   12227                         }
   12228                     }
   12229                 }
   12230                 uppercase(ios);
   12231                 {
   12232                     noshowpos(ios);
   12233                     {
   12234                         noshowpoint(ios);
   12235                         {
   12236                             ios.imbue(lc);
   12237                             {
   12238                                 ios.width(0);
   12239                                 {
   12240                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12241                                     std::string ex(str, iter.base());
   12242                                     assert(ex == "0.0");
   12243                                     assert(ios.width() == 0);
   12244                                 }
   12245                                 ios.width(25);
   12246                                 left(ios);
   12247                                 {
   12248                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12249                                     std::string ex(str, iter.base());
   12250                                     assert(ex == "0.0**********************");
   12251                                     assert(ios.width() == 0);
   12252                                 }
   12253                                 ios.width(25);
   12254                                 right(ios);
   12255                                 {
   12256                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12257                                     std::string ex(str, iter.base());
   12258                                     assert(ex == "**********************0.0");
   12259                                     assert(ios.width() == 0);
   12260                                 }
   12261                                 ios.width(25);
   12262                                 internal(ios);
   12263                                 {
   12264                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12265                                     std::string ex(str, iter.base());
   12266                                     assert(ex == "**********************0.0");
   12267                                     assert(ios.width() == 0);
   12268                                 }
   12269                             }
   12270                             ios.imbue(lg);
   12271                             {
   12272                                 ios.width(0);
   12273                                 {
   12274                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12275                                     std::string ex(str, iter.base());
   12276                                     assert(ex == "0;0");
   12277                                     assert(ios.width() == 0);
   12278                                 }
   12279                                 ios.width(25);
   12280                                 left(ios);
   12281                                 {
   12282                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12283                                     std::string ex(str, iter.base());
   12284                                     assert(ex == "0;0**********************");
   12285                                     assert(ios.width() == 0);
   12286                                 }
   12287                                 ios.width(25);
   12288                                 right(ios);
   12289                                 {
   12290                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12291                                     std::string ex(str, iter.base());
   12292                                     assert(ex == "**********************0;0");
   12293                                     assert(ios.width() == 0);
   12294                                 }
   12295                                 ios.width(25);
   12296                                 internal(ios);
   12297                                 {
   12298                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12299                                     std::string ex(str, iter.base());
   12300                                     assert(ex == "**********************0;0");
   12301                                     assert(ios.width() == 0);
   12302                                 }
   12303                             }
   12304                         }
   12305                         showpoint(ios);
   12306                         {
   12307                             ios.imbue(lc);
   12308                             {
   12309                                 ios.width(0);
   12310                                 {
   12311                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12312                                     std::string ex(str, iter.base());
   12313                                     assert(ex == "0.0");
   12314                                     assert(ios.width() == 0);
   12315                                 }
   12316                                 ios.width(25);
   12317                                 left(ios);
   12318                                 {
   12319                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12320                                     std::string ex(str, iter.base());
   12321                                     assert(ex == "0.0**********************");
   12322                                     assert(ios.width() == 0);
   12323                                 }
   12324                                 ios.width(25);
   12325                                 right(ios);
   12326                                 {
   12327                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12328                                     std::string ex(str, iter.base());
   12329                                     assert(ex == "**********************0.0");
   12330                                     assert(ios.width() == 0);
   12331                                 }
   12332                                 ios.width(25);
   12333                                 internal(ios);
   12334                                 {
   12335                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12336                                     std::string ex(str, iter.base());
   12337                                     assert(ex == "**********************0.0");
   12338                                     assert(ios.width() == 0);
   12339                                 }
   12340                             }
   12341                             ios.imbue(lg);
   12342                             {
   12343                                 ios.width(0);
   12344                                 {
   12345                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12346                                     std::string ex(str, iter.base());
   12347                                     assert(ex == "0;0");
   12348                                     assert(ios.width() == 0);
   12349                                 }
   12350                                 ios.width(25);
   12351                                 left(ios);
   12352                                 {
   12353                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12354                                     std::string ex(str, iter.base());
   12355                                     assert(ex == "0;0**********************");
   12356                                     assert(ios.width() == 0);
   12357                                 }
   12358                                 ios.width(25);
   12359                                 right(ios);
   12360                                 {
   12361                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12362                                     std::string ex(str, iter.base());
   12363                                     assert(ex == "**********************0;0");
   12364                                     assert(ios.width() == 0);
   12365                                 }
   12366                                 ios.width(25);
   12367                                 internal(ios);
   12368                                 {
   12369                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12370                                     std::string ex(str, iter.base());
   12371                                     assert(ex == "**********************0;0");
   12372                                     assert(ios.width() == 0);
   12373                                 }
   12374                             }
   12375                         }
   12376                     }
   12377                     showpos(ios);
   12378                     {
   12379                         noshowpoint(ios);
   12380                         {
   12381                             ios.imbue(lc);
   12382                             {
   12383                                 ios.width(0);
   12384                                 {
   12385                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12386                                     std::string ex(str, iter.base());
   12387                                     assert(ex == "+0.0");
   12388                                     assert(ios.width() == 0);
   12389                                 }
   12390                                 ios.width(25);
   12391                                 left(ios);
   12392                                 {
   12393                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12394                                     std::string ex(str, iter.base());
   12395                                     assert(ex == "+0.0*********************");
   12396                                     assert(ios.width() == 0);
   12397                                 }
   12398                                 ios.width(25);
   12399                                 right(ios);
   12400                                 {
   12401                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12402                                     std::string ex(str, iter.base());
   12403                                     assert(ex == "*********************+0.0");
   12404                                     assert(ios.width() == 0);
   12405                                 }
   12406                                 ios.width(25);
   12407                                 internal(ios);
   12408                                 {
   12409                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12410                                     std::string ex(str, iter.base());
   12411                                     assert(ex == "+*********************0.0");
   12412                                     assert(ios.width() == 0);
   12413                                 }
   12414                             }
   12415                             ios.imbue(lg);
   12416                             {
   12417                                 ios.width(0);
   12418                                 {
   12419                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12420                                     std::string ex(str, iter.base());
   12421                                     assert(ex == "+0;0");
   12422                                     assert(ios.width() == 0);
   12423                                 }
   12424                                 ios.width(25);
   12425                                 left(ios);
   12426                                 {
   12427                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12428                                     std::string ex(str, iter.base());
   12429                                     assert(ex == "+0;0*********************");
   12430                                     assert(ios.width() == 0);
   12431                                 }
   12432                                 ios.width(25);
   12433                                 right(ios);
   12434                                 {
   12435                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12436                                     std::string ex(str, iter.base());
   12437                                     assert(ex == "*********************+0;0");
   12438                                     assert(ios.width() == 0);
   12439                                 }
   12440                                 ios.width(25);
   12441                                 internal(ios);
   12442                                 {
   12443                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12444                                     std::string ex(str, iter.base());
   12445                                     assert(ex == "+*********************0;0");
   12446                                     assert(ios.width() == 0);
   12447                                 }
   12448                             }
   12449                         }
   12450                         showpoint(ios);
   12451                         {
   12452                             ios.imbue(lc);
   12453                             {
   12454                                 ios.width(0);
   12455                                 {
   12456                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12457                                     std::string ex(str, iter.base());
   12458                                     assert(ex == "+0.0");
   12459                                     assert(ios.width() == 0);
   12460                                 }
   12461                                 ios.width(25);
   12462                                 left(ios);
   12463                                 {
   12464                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12465                                     std::string ex(str, iter.base());
   12466                                     assert(ex == "+0.0*********************");
   12467                                     assert(ios.width() == 0);
   12468                                 }
   12469                                 ios.width(25);
   12470                                 right(ios);
   12471                                 {
   12472                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12473                                     std::string ex(str, iter.base());
   12474                                     assert(ex == "*********************+0.0");
   12475                                     assert(ios.width() == 0);
   12476                                 }
   12477                                 ios.width(25);
   12478                                 internal(ios);
   12479                                 {
   12480                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12481                                     std::string ex(str, iter.base());
   12482                                     assert(ex == "+*********************0.0");
   12483                                     assert(ios.width() == 0);
   12484                                 }
   12485                             }
   12486                             ios.imbue(lg);
   12487                             {
   12488                                 ios.width(0);
   12489                                 {
   12490                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12491                                     std::string ex(str, iter.base());
   12492                                     assert(ex == "+0;0");
   12493                                     assert(ios.width() == 0);
   12494                                 }
   12495                                 ios.width(25);
   12496                                 left(ios);
   12497                                 {
   12498                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12499                                     std::string ex(str, iter.base());
   12500                                     assert(ex == "+0;0*********************");
   12501                                     assert(ios.width() == 0);
   12502                                 }
   12503                                 ios.width(25);
   12504                                 right(ios);
   12505                                 {
   12506                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12507                                     std::string ex(str, iter.base());
   12508                                     assert(ex == "*********************+0;0");
   12509                                     assert(ios.width() == 0);
   12510                                 }
   12511                                 ios.width(25);
   12512                                 internal(ios);
   12513                                 {
   12514                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12515                                     std::string ex(str, iter.base());
   12516                                     assert(ex == "+*********************0;0");
   12517                                     assert(ios.width() == 0);
   12518                                 }
   12519                             }
   12520                         }
   12521                     }
   12522                 }
   12523             }
   12524             ios.precision(6);
   12525             {
   12526                 nouppercase(ios);
   12527                 {
   12528                     noshowpos(ios);
   12529                     {
   12530                         noshowpoint(ios);
   12531                         {
   12532                             ios.imbue(lc);
   12533                             {
   12534                                 ios.width(0);
   12535                                 {
   12536                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12537                                     std::string ex(str, iter.base());
   12538                                     assert(ex == "0.000000");
   12539                                     assert(ios.width() == 0);
   12540                                 }
   12541                                 ios.width(25);
   12542                                 left(ios);
   12543                                 {
   12544                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12545                                     std::string ex(str, iter.base());
   12546                                     assert(ex == "0.000000*****************");
   12547                                     assert(ios.width() == 0);
   12548                                 }
   12549                                 ios.width(25);
   12550                                 right(ios);
   12551                                 {
   12552                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12553                                     std::string ex(str, iter.base());
   12554                                     assert(ex == "*****************0.000000");
   12555                                     assert(ios.width() == 0);
   12556                                 }
   12557                                 ios.width(25);
   12558                                 internal(ios);
   12559                                 {
   12560                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12561                                     std::string ex(str, iter.base());
   12562                                     assert(ex == "*****************0.000000");
   12563                                     assert(ios.width() == 0);
   12564                                 }
   12565                             }
   12566                             ios.imbue(lg);
   12567                             {
   12568                                 ios.width(0);
   12569                                 {
   12570                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12571                                     std::string ex(str, iter.base());
   12572                                     assert(ex == "0;000000");
   12573                                     assert(ios.width() == 0);
   12574                                 }
   12575                                 ios.width(25);
   12576                                 left(ios);
   12577                                 {
   12578                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12579                                     std::string ex(str, iter.base());
   12580                                     assert(ex == "0;000000*****************");
   12581                                     assert(ios.width() == 0);
   12582                                 }
   12583                                 ios.width(25);
   12584                                 right(ios);
   12585                                 {
   12586                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12587                                     std::string ex(str, iter.base());
   12588                                     assert(ex == "*****************0;000000");
   12589                                     assert(ios.width() == 0);
   12590                                 }
   12591                                 ios.width(25);
   12592                                 internal(ios);
   12593                                 {
   12594                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12595                                     std::string ex(str, iter.base());
   12596                                     assert(ex == "*****************0;000000");
   12597                                     assert(ios.width() == 0);
   12598                                 }
   12599                             }
   12600                         }
   12601                         showpoint(ios);
   12602                         {
   12603                             ios.imbue(lc);
   12604                             {
   12605                                 ios.width(0);
   12606                                 {
   12607                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12608                                     std::string ex(str, iter.base());
   12609                                     assert(ex == "0.000000");
   12610                                     assert(ios.width() == 0);
   12611                                 }
   12612                                 ios.width(25);
   12613                                 left(ios);
   12614                                 {
   12615                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12616                                     std::string ex(str, iter.base());
   12617                                     assert(ex == "0.000000*****************");
   12618                                     assert(ios.width() == 0);
   12619                                 }
   12620                                 ios.width(25);
   12621                                 right(ios);
   12622                                 {
   12623                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12624                                     std::string ex(str, iter.base());
   12625                                     assert(ex == "*****************0.000000");
   12626                                     assert(ios.width() == 0);
   12627                                 }
   12628                                 ios.width(25);
   12629                                 internal(ios);
   12630                                 {
   12631                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12632                                     std::string ex(str, iter.base());
   12633                                     assert(ex == "*****************0.000000");
   12634                                     assert(ios.width() == 0);
   12635                                 }
   12636                             }
   12637                             ios.imbue(lg);
   12638                             {
   12639                                 ios.width(0);
   12640                                 {
   12641                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12642                                     std::string ex(str, iter.base());
   12643                                     assert(ex == "0;000000");
   12644                                     assert(ios.width() == 0);
   12645                                 }
   12646                                 ios.width(25);
   12647                                 left(ios);
   12648                                 {
   12649                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12650                                     std::string ex(str, iter.base());
   12651                                     assert(ex == "0;000000*****************");
   12652                                     assert(ios.width() == 0);
   12653                                 }
   12654                                 ios.width(25);
   12655                                 right(ios);
   12656                                 {
   12657                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12658                                     std::string ex(str, iter.base());
   12659                                     assert(ex == "*****************0;000000");
   12660                                     assert(ios.width() == 0);
   12661                                 }
   12662                                 ios.width(25);
   12663                                 internal(ios);
   12664                                 {
   12665                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12666                                     std::string ex(str, iter.base());
   12667                                     assert(ex == "*****************0;000000");
   12668                                     assert(ios.width() == 0);
   12669                                 }
   12670                             }
   12671                         }
   12672                     }
   12673                     showpos(ios);
   12674                     {
   12675                         noshowpoint(ios);
   12676                         {
   12677                             ios.imbue(lc);
   12678                             {
   12679                                 ios.width(0);
   12680                                 {
   12681                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12682                                     std::string ex(str, iter.base());
   12683                                     assert(ex == "+0.000000");
   12684                                     assert(ios.width() == 0);
   12685                                 }
   12686                                 ios.width(25);
   12687                                 left(ios);
   12688                                 {
   12689                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12690                                     std::string ex(str, iter.base());
   12691                                     assert(ex == "+0.000000****************");
   12692                                     assert(ios.width() == 0);
   12693                                 }
   12694                                 ios.width(25);
   12695                                 right(ios);
   12696                                 {
   12697                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12698                                     std::string ex(str, iter.base());
   12699                                     assert(ex == "****************+0.000000");
   12700                                     assert(ios.width() == 0);
   12701                                 }
   12702                                 ios.width(25);
   12703                                 internal(ios);
   12704                                 {
   12705                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12706                                     std::string ex(str, iter.base());
   12707                                     assert(ex == "+****************0.000000");
   12708                                     assert(ios.width() == 0);
   12709                                 }
   12710                             }
   12711                             ios.imbue(lg);
   12712                             {
   12713                                 ios.width(0);
   12714                                 {
   12715                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12716                                     std::string ex(str, iter.base());
   12717                                     assert(ex == "+0;000000");
   12718                                     assert(ios.width() == 0);
   12719                                 }
   12720                                 ios.width(25);
   12721                                 left(ios);
   12722                                 {
   12723                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12724                                     std::string ex(str, iter.base());
   12725                                     assert(ex == "+0;000000****************");
   12726                                     assert(ios.width() == 0);
   12727                                 }
   12728                                 ios.width(25);
   12729                                 right(ios);
   12730                                 {
   12731                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12732                                     std::string ex(str, iter.base());
   12733                                     assert(ex == "****************+0;000000");
   12734                                     assert(ios.width() == 0);
   12735                                 }
   12736                                 ios.width(25);
   12737                                 internal(ios);
   12738                                 {
   12739                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12740                                     std::string ex(str, iter.base());
   12741                                     assert(ex == "+****************0;000000");
   12742                                     assert(ios.width() == 0);
   12743                                 }
   12744                             }
   12745                         }
   12746                         showpoint(ios);
   12747                         {
   12748                             ios.imbue(lc);
   12749                             {
   12750                                 ios.width(0);
   12751                                 {
   12752                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12753                                     std::string ex(str, iter.base());
   12754                                     assert(ex == "+0.000000");
   12755                                     assert(ios.width() == 0);
   12756                                 }
   12757                                 ios.width(25);
   12758                                 left(ios);
   12759                                 {
   12760                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12761                                     std::string ex(str, iter.base());
   12762                                     assert(ex == "+0.000000****************");
   12763                                     assert(ios.width() == 0);
   12764                                 }
   12765                                 ios.width(25);
   12766                                 right(ios);
   12767                                 {
   12768                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12769                                     std::string ex(str, iter.base());
   12770                                     assert(ex == "****************+0.000000");
   12771                                     assert(ios.width() == 0);
   12772                                 }
   12773                                 ios.width(25);
   12774                                 internal(ios);
   12775                                 {
   12776                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12777                                     std::string ex(str, iter.base());
   12778                                     assert(ex == "+****************0.000000");
   12779                                     assert(ios.width() == 0);
   12780                                 }
   12781                             }
   12782                             ios.imbue(lg);
   12783                             {
   12784                                 ios.width(0);
   12785                                 {
   12786                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12787                                     std::string ex(str, iter.base());
   12788                                     assert(ex == "+0;000000");
   12789                                     assert(ios.width() == 0);
   12790                                 }
   12791                                 ios.width(25);
   12792                                 left(ios);
   12793                                 {
   12794                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12795                                     std::string ex(str, iter.base());
   12796                                     assert(ex == "+0;000000****************");
   12797                                     assert(ios.width() == 0);
   12798                                 }
   12799                                 ios.width(25);
   12800                                 right(ios);
   12801                                 {
   12802                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12803                                     std::string ex(str, iter.base());
   12804                                     assert(ex == "****************+0;000000");
   12805                                     assert(ios.width() == 0);
   12806                                 }
   12807                                 ios.width(25);
   12808                                 internal(ios);
   12809                                 {
   12810                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12811                                     std::string ex(str, iter.base());
   12812                                     assert(ex == "+****************0;000000");
   12813                                     assert(ios.width() == 0);
   12814                                 }
   12815                             }
   12816                         }
   12817                     }
   12818                 }
   12819                 uppercase(ios);
   12820                 {
   12821                     noshowpos(ios);
   12822                     {
   12823                         noshowpoint(ios);
   12824                         {
   12825                             ios.imbue(lc);
   12826                             {
   12827                                 ios.width(0);
   12828                                 {
   12829                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12830                                     std::string ex(str, iter.base());
   12831                                     assert(ex == "0.000000");
   12832                                     assert(ios.width() == 0);
   12833                                 }
   12834                                 ios.width(25);
   12835                                 left(ios);
   12836                                 {
   12837                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12838                                     std::string ex(str, iter.base());
   12839                                     assert(ex == "0.000000*****************");
   12840                                     assert(ios.width() == 0);
   12841                                 }
   12842                                 ios.width(25);
   12843                                 right(ios);
   12844                                 {
   12845                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12846                                     std::string ex(str, iter.base());
   12847                                     assert(ex == "*****************0.000000");
   12848                                     assert(ios.width() == 0);
   12849                                 }
   12850                                 ios.width(25);
   12851                                 internal(ios);
   12852                                 {
   12853                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12854                                     std::string ex(str, iter.base());
   12855                                     assert(ex == "*****************0.000000");
   12856                                     assert(ios.width() == 0);
   12857                                 }
   12858                             }
   12859                             ios.imbue(lg);
   12860                             {
   12861                                 ios.width(0);
   12862                                 {
   12863                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12864                                     std::string ex(str, iter.base());
   12865                                     assert(ex == "0;000000");
   12866                                     assert(ios.width() == 0);
   12867                                 }
   12868                                 ios.width(25);
   12869                                 left(ios);
   12870                                 {
   12871                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12872                                     std::string ex(str, iter.base());
   12873                                     assert(ex == "0;000000*****************");
   12874                                     assert(ios.width() == 0);
   12875                                 }
   12876                                 ios.width(25);
   12877                                 right(ios);
   12878                                 {
   12879                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12880                                     std::string ex(str, iter.base());
   12881                                     assert(ex == "*****************0;000000");
   12882                                     assert(ios.width() == 0);
   12883                                 }
   12884                                 ios.width(25);
   12885                                 internal(ios);
   12886                                 {
   12887                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12888                                     std::string ex(str, iter.base());
   12889                                     assert(ex == "*****************0;000000");
   12890                                     assert(ios.width() == 0);
   12891                                 }
   12892                             }
   12893                         }
   12894                         showpoint(ios);
   12895                         {
   12896                             ios.imbue(lc);
   12897                             {
   12898                                 ios.width(0);
   12899                                 {
   12900                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12901                                     std::string ex(str, iter.base());
   12902                                     assert(ex == "0.000000");
   12903                                     assert(ios.width() == 0);
   12904                                 }
   12905                                 ios.width(25);
   12906                                 left(ios);
   12907                                 {
   12908                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12909                                     std::string ex(str, iter.base());
   12910                                     assert(ex == "0.000000*****************");
   12911                                     assert(ios.width() == 0);
   12912                                 }
   12913                                 ios.width(25);
   12914                                 right(ios);
   12915                                 {
   12916                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12917                                     std::string ex(str, iter.base());
   12918                                     assert(ex == "*****************0.000000");
   12919                                     assert(ios.width() == 0);
   12920                                 }
   12921                                 ios.width(25);
   12922                                 internal(ios);
   12923                                 {
   12924                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12925                                     std::string ex(str, iter.base());
   12926                                     assert(ex == "*****************0.000000");
   12927                                     assert(ios.width() == 0);
   12928                                 }
   12929                             }
   12930                             ios.imbue(lg);
   12931                             {
   12932                                 ios.width(0);
   12933                                 {
   12934                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12935                                     std::string ex(str, iter.base());
   12936                                     assert(ex == "0;000000");
   12937                                     assert(ios.width() == 0);
   12938                                 }
   12939                                 ios.width(25);
   12940                                 left(ios);
   12941                                 {
   12942                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12943                                     std::string ex(str, iter.base());
   12944                                     assert(ex == "0;000000*****************");
   12945                                     assert(ios.width() == 0);
   12946                                 }
   12947                                 ios.width(25);
   12948                                 right(ios);
   12949                                 {
   12950                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12951                                     std::string ex(str, iter.base());
   12952                                     assert(ex == "*****************0;000000");
   12953                                     assert(ios.width() == 0);
   12954                                 }
   12955                                 ios.width(25);
   12956                                 internal(ios);
   12957                                 {
   12958                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12959                                     std::string ex(str, iter.base());
   12960                                     assert(ex == "*****************0;000000");
   12961                                     assert(ios.width() == 0);
   12962                                 }
   12963                             }
   12964                         }
   12965                     }
   12966                     showpos(ios);
   12967                     {
   12968                         noshowpoint(ios);
   12969                         {
   12970                             ios.imbue(lc);
   12971                             {
   12972                                 ios.width(0);
   12973                                 {
   12974                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12975                                     std::string ex(str, iter.base());
   12976                                     assert(ex == "+0.000000");
   12977                                     assert(ios.width() == 0);
   12978                                 }
   12979                                 ios.width(25);
   12980                                 left(ios);
   12981                                 {
   12982                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12983                                     std::string ex(str, iter.base());
   12984                                     assert(ex == "+0.000000****************");
   12985                                     assert(ios.width() == 0);
   12986                                 }
   12987                                 ios.width(25);
   12988                                 right(ios);
   12989                                 {
   12990                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12991                                     std::string ex(str, iter.base());
   12992                                     assert(ex == "****************+0.000000");
   12993                                     assert(ios.width() == 0);
   12994                                 }
   12995                                 ios.width(25);
   12996                                 internal(ios);
   12997                                 {
   12998                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12999                                     std::string ex(str, iter.base());
   13000                                     assert(ex == "+****************0.000000");
   13001                                     assert(ios.width() == 0);
   13002                                 }
   13003                             }
   13004                             ios.imbue(lg);
   13005                             {
   13006                                 ios.width(0);
   13007                                 {
   13008                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13009                                     std::string ex(str, iter.base());
   13010                                     assert(ex == "+0;000000");
   13011                                     assert(ios.width() == 0);
   13012                                 }
   13013                                 ios.width(25);
   13014                                 left(ios);
   13015                                 {
   13016                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13017                                     std::string ex(str, iter.base());
   13018                                     assert(ex == "+0;000000****************");
   13019                                     assert(ios.width() == 0);
   13020                                 }
   13021                                 ios.width(25);
   13022                                 right(ios);
   13023                                 {
   13024                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13025                                     std::string ex(str, iter.base());
   13026                                     assert(ex == "****************+0;000000");
   13027                                     assert(ios.width() == 0);
   13028                                 }
   13029                                 ios.width(25);
   13030                                 internal(ios);
   13031                                 {
   13032                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13033                                     std::string ex(str, iter.base());
   13034                                     assert(ex == "+****************0;000000");
   13035                                     assert(ios.width() == 0);
   13036                                 }
   13037                             }
   13038                         }
   13039                         showpoint(ios);
   13040                         {
   13041                             ios.imbue(lc);
   13042                             {
   13043                                 ios.width(0);
   13044                                 {
   13045                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13046                                     std::string ex(str, iter.base());
   13047                                     assert(ex == "+0.000000");
   13048                                     assert(ios.width() == 0);
   13049                                 }
   13050                                 ios.width(25);
   13051                                 left(ios);
   13052                                 {
   13053                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13054                                     std::string ex(str, iter.base());
   13055                                     assert(ex == "+0.000000****************");
   13056                                     assert(ios.width() == 0);
   13057                                 }
   13058                                 ios.width(25);
   13059                                 right(ios);
   13060                                 {
   13061                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13062                                     std::string ex(str, iter.base());
   13063                                     assert(ex == "****************+0.000000");
   13064                                     assert(ios.width() == 0);
   13065                                 }
   13066                                 ios.width(25);
   13067                                 internal(ios);
   13068                                 {
   13069                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13070                                     std::string ex(str, iter.base());
   13071                                     assert(ex == "+****************0.000000");
   13072                                     assert(ios.width() == 0);
   13073                                 }
   13074                             }
   13075                             ios.imbue(lg);
   13076                             {
   13077                                 ios.width(0);
   13078                                 {
   13079                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13080                                     std::string ex(str, iter.base());
   13081                                     assert(ex == "+0;000000");
   13082                                     assert(ios.width() == 0);
   13083                                 }
   13084                                 ios.width(25);
   13085                                 left(ios);
   13086                                 {
   13087                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13088                                     std::string ex(str, iter.base());
   13089                                     assert(ex == "+0;000000****************");
   13090                                     assert(ios.width() == 0);
   13091                                 }
   13092                                 ios.width(25);
   13093                                 right(ios);
   13094                                 {
   13095                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13096                                     std::string ex(str, iter.base());
   13097                                     assert(ex == "****************+0;000000");
   13098                                     assert(ios.width() == 0);
   13099                                 }
   13100                                 ios.width(25);
   13101                                 internal(ios);
   13102                                 {
   13103                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13104                                     std::string ex(str, iter.base());
   13105                                     assert(ex == "+****************0;000000");
   13106                                     assert(ios.width() == 0);
   13107                                 }
   13108                             }
   13109                         }
   13110                     }
   13111                 }
   13112             }
   13113             ios.precision(16);
   13114             {
   13115                 nouppercase(ios);
   13116                 {
   13117                     noshowpos(ios);
   13118                     {
   13119                         noshowpoint(ios);
   13120                         {
   13121                             ios.imbue(lc);
   13122                             {
   13123                                 ios.width(0);
   13124                                 {
   13125                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13126                                     std::string ex(str, iter.base());
   13127                                     assert(ex == "0.0000000000000000");
   13128                                     assert(ios.width() == 0);
   13129                                 }
   13130                                 ios.width(25);
   13131                                 left(ios);
   13132                                 {
   13133                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13134                                     std::string ex(str, iter.base());
   13135                                     assert(ex == "0.0000000000000000*******");
   13136                                     assert(ios.width() == 0);
   13137                                 }
   13138                                 ios.width(25);
   13139                                 right(ios);
   13140                                 {
   13141                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13142                                     std::string ex(str, iter.base());
   13143                                     assert(ex == "*******0.0000000000000000");
   13144                                     assert(ios.width() == 0);
   13145                                 }
   13146                                 ios.width(25);
   13147                                 internal(ios);
   13148                                 {
   13149                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13150                                     std::string ex(str, iter.base());
   13151                                     assert(ex == "*******0.0000000000000000");
   13152                                     assert(ios.width() == 0);
   13153                                 }
   13154                             }
   13155                             ios.imbue(lg);
   13156                             {
   13157                                 ios.width(0);
   13158                                 {
   13159                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13160                                     std::string ex(str, iter.base());
   13161                                     assert(ex == "0;0000000000000000");
   13162                                     assert(ios.width() == 0);
   13163                                 }
   13164                                 ios.width(25);
   13165                                 left(ios);
   13166                                 {
   13167                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13168                                     std::string ex(str, iter.base());
   13169                                     assert(ex == "0;0000000000000000*******");
   13170                                     assert(ios.width() == 0);
   13171                                 }
   13172                                 ios.width(25);
   13173                                 right(ios);
   13174                                 {
   13175                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13176                                     std::string ex(str, iter.base());
   13177                                     assert(ex == "*******0;0000000000000000");
   13178                                     assert(ios.width() == 0);
   13179                                 }
   13180                                 ios.width(25);
   13181                                 internal(ios);
   13182                                 {
   13183                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13184                                     std::string ex(str, iter.base());
   13185                                     assert(ex == "*******0;0000000000000000");
   13186                                     assert(ios.width() == 0);
   13187                                 }
   13188                             }
   13189                         }
   13190                         showpoint(ios);
   13191                         {
   13192                             ios.imbue(lc);
   13193                             {
   13194                                 ios.width(0);
   13195                                 {
   13196                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13197                                     std::string ex(str, iter.base());
   13198                                     assert(ex == "0.0000000000000000");
   13199                                     assert(ios.width() == 0);
   13200                                 }
   13201                                 ios.width(25);
   13202                                 left(ios);
   13203                                 {
   13204                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13205                                     std::string ex(str, iter.base());
   13206                                     assert(ex == "0.0000000000000000*******");
   13207                                     assert(ios.width() == 0);
   13208                                 }
   13209                                 ios.width(25);
   13210                                 right(ios);
   13211                                 {
   13212                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13213                                     std::string ex(str, iter.base());
   13214                                     assert(ex == "*******0.0000000000000000");
   13215                                     assert(ios.width() == 0);
   13216                                 }
   13217                                 ios.width(25);
   13218                                 internal(ios);
   13219                                 {
   13220                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13221                                     std::string ex(str, iter.base());
   13222                                     assert(ex == "*******0.0000000000000000");
   13223                                     assert(ios.width() == 0);
   13224                                 }
   13225                             }
   13226                             ios.imbue(lg);
   13227                             {
   13228                                 ios.width(0);
   13229                                 {
   13230                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13231                                     std::string ex(str, iter.base());
   13232                                     assert(ex == "0;0000000000000000");
   13233                                     assert(ios.width() == 0);
   13234                                 }
   13235                                 ios.width(25);
   13236                                 left(ios);
   13237                                 {
   13238                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13239                                     std::string ex(str, iter.base());
   13240                                     assert(ex == "0;0000000000000000*******");
   13241                                     assert(ios.width() == 0);
   13242                                 }
   13243                                 ios.width(25);
   13244                                 right(ios);
   13245                                 {
   13246                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13247                                     std::string ex(str, iter.base());
   13248                                     assert(ex == "*******0;0000000000000000");
   13249                                     assert(ios.width() == 0);
   13250                                 }
   13251                                 ios.width(25);
   13252                                 internal(ios);
   13253                                 {
   13254                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13255                                     std::string ex(str, iter.base());
   13256                                     assert(ex == "*******0;0000000000000000");
   13257                                     assert(ios.width() == 0);
   13258                                 }
   13259                             }
   13260                         }
   13261                     }
   13262                     showpos(ios);
   13263                     {
   13264                         noshowpoint(ios);
   13265                         {
   13266                             ios.imbue(lc);
   13267                             {
   13268                                 ios.width(0);
   13269                                 {
   13270                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13271                                     std::string ex(str, iter.base());
   13272                                     assert(ex == "+0.0000000000000000");
   13273                                     assert(ios.width() == 0);
   13274                                 }
   13275                                 ios.width(25);
   13276                                 left(ios);
   13277                                 {
   13278                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13279                                     std::string ex(str, iter.base());
   13280                                     assert(ex == "+0.0000000000000000******");
   13281                                     assert(ios.width() == 0);
   13282                                 }
   13283                                 ios.width(25);
   13284                                 right(ios);
   13285                                 {
   13286                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13287                                     std::string ex(str, iter.base());
   13288                                     assert(ex == "******+0.0000000000000000");
   13289                                     assert(ios.width() == 0);
   13290                                 }
   13291                                 ios.width(25);
   13292                                 internal(ios);
   13293                                 {
   13294                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13295                                     std::string ex(str, iter.base());
   13296                                     assert(ex == "+******0.0000000000000000");
   13297                                     assert(ios.width() == 0);
   13298                                 }
   13299                             }
   13300                             ios.imbue(lg);
   13301                             {
   13302                                 ios.width(0);
   13303                                 {
   13304                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13305                                     std::string ex(str, iter.base());
   13306                                     assert(ex == "+0;0000000000000000");
   13307                                     assert(ios.width() == 0);
   13308                                 }
   13309                                 ios.width(25);
   13310                                 left(ios);
   13311                                 {
   13312                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13313                                     std::string ex(str, iter.base());
   13314                                     assert(ex == "+0;0000000000000000******");
   13315                                     assert(ios.width() == 0);
   13316                                 }
   13317                                 ios.width(25);
   13318                                 right(ios);
   13319                                 {
   13320                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13321                                     std::string ex(str, iter.base());
   13322                                     assert(ex == "******+0;0000000000000000");
   13323                                     assert(ios.width() == 0);
   13324                                 }
   13325                                 ios.width(25);
   13326                                 internal(ios);
   13327                                 {
   13328                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13329                                     std::string ex(str, iter.base());
   13330                                     assert(ex == "+******0;0000000000000000");
   13331                                     assert(ios.width() == 0);
   13332                                 }
   13333                             }
   13334                         }
   13335                         showpoint(ios);
   13336                         {
   13337                             ios.imbue(lc);
   13338                             {
   13339                                 ios.width(0);
   13340                                 {
   13341                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13342                                     std::string ex(str, iter.base());
   13343                                     assert(ex == "+0.0000000000000000");
   13344                                     assert(ios.width() == 0);
   13345                                 }
   13346                                 ios.width(25);
   13347                                 left(ios);
   13348                                 {
   13349                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13350                                     std::string ex(str, iter.base());
   13351                                     assert(ex == "+0.0000000000000000******");
   13352                                     assert(ios.width() == 0);
   13353                                 }
   13354                                 ios.width(25);
   13355                                 right(ios);
   13356                                 {
   13357                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13358                                     std::string ex(str, iter.base());
   13359                                     assert(ex == "******+0.0000000000000000");
   13360                                     assert(ios.width() == 0);
   13361                                 }
   13362                                 ios.width(25);
   13363                                 internal(ios);
   13364                                 {
   13365                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13366                                     std::string ex(str, iter.base());
   13367                                     assert(ex == "+******0.0000000000000000");
   13368                                     assert(ios.width() == 0);
   13369                                 }
   13370                             }
   13371                             ios.imbue(lg);
   13372                             {
   13373                                 ios.width(0);
   13374                                 {
   13375                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13376                                     std::string ex(str, iter.base());
   13377                                     assert(ex == "+0;0000000000000000");
   13378                                     assert(ios.width() == 0);
   13379                                 }
   13380                                 ios.width(25);
   13381                                 left(ios);
   13382                                 {
   13383                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13384                                     std::string ex(str, iter.base());
   13385                                     assert(ex == "+0;0000000000000000******");
   13386                                     assert(ios.width() == 0);
   13387                                 }
   13388                                 ios.width(25);
   13389                                 right(ios);
   13390                                 {
   13391                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13392                                     std::string ex(str, iter.base());
   13393                                     assert(ex == "******+0;0000000000000000");
   13394                                     assert(ios.width() == 0);
   13395                                 }
   13396                                 ios.width(25);
   13397                                 internal(ios);
   13398                                 {
   13399                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13400                                     std::string ex(str, iter.base());
   13401                                     assert(ex == "+******0;0000000000000000");
   13402                                     assert(ios.width() == 0);
   13403                                 }
   13404                             }
   13405                         }
   13406                     }
   13407                 }
   13408                 uppercase(ios);
   13409                 {
   13410                     noshowpos(ios);
   13411                     {
   13412                         noshowpoint(ios);
   13413                         {
   13414                             ios.imbue(lc);
   13415                             {
   13416                                 ios.width(0);
   13417                                 {
   13418                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13419                                     std::string ex(str, iter.base());
   13420                                     assert(ex == "0.0000000000000000");
   13421                                     assert(ios.width() == 0);
   13422                                 }
   13423                                 ios.width(25);
   13424                                 left(ios);
   13425                                 {
   13426                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13427                                     std::string ex(str, iter.base());
   13428                                     assert(ex == "0.0000000000000000*******");
   13429                                     assert(ios.width() == 0);
   13430                                 }
   13431                                 ios.width(25);
   13432                                 right(ios);
   13433                                 {
   13434                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13435                                     std::string ex(str, iter.base());
   13436                                     assert(ex == "*******0.0000000000000000");
   13437                                     assert(ios.width() == 0);
   13438                                 }
   13439                                 ios.width(25);
   13440                                 internal(ios);
   13441                                 {
   13442                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13443                                     std::string ex(str, iter.base());
   13444                                     assert(ex == "*******0.0000000000000000");
   13445                                     assert(ios.width() == 0);
   13446                                 }
   13447                             }
   13448                             ios.imbue(lg);
   13449                             {
   13450                                 ios.width(0);
   13451                                 {
   13452                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13453                                     std::string ex(str, iter.base());
   13454                                     assert(ex == "0;0000000000000000");
   13455                                     assert(ios.width() == 0);
   13456                                 }
   13457                                 ios.width(25);
   13458                                 left(ios);
   13459                                 {
   13460                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13461                                     std::string ex(str, iter.base());
   13462                                     assert(ex == "0;0000000000000000*******");
   13463                                     assert(ios.width() == 0);
   13464                                 }
   13465                                 ios.width(25);
   13466                                 right(ios);
   13467                                 {
   13468                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13469                                     std::string ex(str, iter.base());
   13470                                     assert(ex == "*******0;0000000000000000");
   13471                                     assert(ios.width() == 0);
   13472                                 }
   13473                                 ios.width(25);
   13474                                 internal(ios);
   13475                                 {
   13476                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13477                                     std::string ex(str, iter.base());
   13478                                     assert(ex == "*******0;0000000000000000");
   13479                                     assert(ios.width() == 0);
   13480                                 }
   13481                             }
   13482                         }
   13483                         showpoint(ios);
   13484                         {
   13485                             ios.imbue(lc);
   13486                             {
   13487                                 ios.width(0);
   13488                                 {
   13489                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13490                                     std::string ex(str, iter.base());
   13491                                     assert(ex == "0.0000000000000000");
   13492                                     assert(ios.width() == 0);
   13493                                 }
   13494                                 ios.width(25);
   13495                                 left(ios);
   13496                                 {
   13497                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13498                                     std::string ex(str, iter.base());
   13499                                     assert(ex == "0.0000000000000000*******");
   13500                                     assert(ios.width() == 0);
   13501                                 }
   13502                                 ios.width(25);
   13503                                 right(ios);
   13504                                 {
   13505                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13506                                     std::string ex(str, iter.base());
   13507                                     assert(ex == "*******0.0000000000000000");
   13508                                     assert(ios.width() == 0);
   13509                                 }
   13510                                 ios.width(25);
   13511                                 internal(ios);
   13512                                 {
   13513                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13514                                     std::string ex(str, iter.base());
   13515                                     assert(ex == "*******0.0000000000000000");
   13516                                     assert(ios.width() == 0);
   13517                                 }
   13518                             }
   13519                             ios.imbue(lg);
   13520                             {
   13521                                 ios.width(0);
   13522                                 {
   13523                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13524                                     std::string ex(str, iter.base());
   13525                                     assert(ex == "0;0000000000000000");
   13526                                     assert(ios.width() == 0);
   13527                                 }
   13528                                 ios.width(25);
   13529                                 left(ios);
   13530                                 {
   13531                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13532                                     std::string ex(str, iter.base());
   13533                                     assert(ex == "0;0000000000000000*******");
   13534                                     assert(ios.width() == 0);
   13535                                 }
   13536                                 ios.width(25);
   13537                                 right(ios);
   13538                                 {
   13539                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13540                                     std::string ex(str, iter.base());
   13541                                     assert(ex == "*******0;0000000000000000");
   13542                                     assert(ios.width() == 0);
   13543                                 }
   13544                                 ios.width(25);
   13545                                 internal(ios);
   13546                                 {
   13547                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13548                                     std::string ex(str, iter.base());
   13549                                     assert(ex == "*******0;0000000000000000");
   13550                                     assert(ios.width() == 0);
   13551                                 }
   13552                             }
   13553                         }
   13554                     }
   13555                     showpos(ios);
   13556                     {
   13557                         noshowpoint(ios);
   13558                         {
   13559                             ios.imbue(lc);
   13560                             {
   13561                                 ios.width(0);
   13562                                 {
   13563                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13564                                     std::string ex(str, iter.base());
   13565                                     assert(ex == "+0.0000000000000000");
   13566                                     assert(ios.width() == 0);
   13567                                 }
   13568                                 ios.width(25);
   13569                                 left(ios);
   13570                                 {
   13571                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13572                                     std::string ex(str, iter.base());
   13573                                     assert(ex == "+0.0000000000000000******");
   13574                                     assert(ios.width() == 0);
   13575                                 }
   13576                                 ios.width(25);
   13577                                 right(ios);
   13578                                 {
   13579                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13580                                     std::string ex(str, iter.base());
   13581                                     assert(ex == "******+0.0000000000000000");
   13582                                     assert(ios.width() == 0);
   13583                                 }
   13584                                 ios.width(25);
   13585                                 internal(ios);
   13586                                 {
   13587                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13588                                     std::string ex(str, iter.base());
   13589                                     assert(ex == "+******0.0000000000000000");
   13590                                     assert(ios.width() == 0);
   13591                                 }
   13592                             }
   13593                             ios.imbue(lg);
   13594                             {
   13595                                 ios.width(0);
   13596                                 {
   13597                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13598                                     std::string ex(str, iter.base());
   13599                                     assert(ex == "+0;0000000000000000");
   13600                                     assert(ios.width() == 0);
   13601                                 }
   13602                                 ios.width(25);
   13603                                 left(ios);
   13604                                 {
   13605                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13606                                     std::string ex(str, iter.base());
   13607                                     assert(ex == "+0;0000000000000000******");
   13608                                     assert(ios.width() == 0);
   13609                                 }
   13610                                 ios.width(25);
   13611                                 right(ios);
   13612                                 {
   13613                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13614                                     std::string ex(str, iter.base());
   13615                                     assert(ex == "******+0;0000000000000000");
   13616                                     assert(ios.width() == 0);
   13617                                 }
   13618                                 ios.width(25);
   13619                                 internal(ios);
   13620                                 {
   13621                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13622                                     std::string ex(str, iter.base());
   13623                                     assert(ex == "+******0;0000000000000000");
   13624                                     assert(ios.width() == 0);
   13625                                 }
   13626                             }
   13627                         }
   13628                         showpoint(ios);
   13629                         {
   13630                             ios.imbue(lc);
   13631                             {
   13632                                 ios.width(0);
   13633                                 {
   13634                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13635                                     std::string ex(str, iter.base());
   13636                                     assert(ex == "+0.0000000000000000");
   13637                                     assert(ios.width() == 0);
   13638                                 }
   13639                                 ios.width(25);
   13640                                 left(ios);
   13641                                 {
   13642                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13643                                     std::string ex(str, iter.base());
   13644                                     assert(ex == "+0.0000000000000000******");
   13645                                     assert(ios.width() == 0);
   13646                                 }
   13647                                 ios.width(25);
   13648                                 right(ios);
   13649                                 {
   13650                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13651                                     std::string ex(str, iter.base());
   13652                                     assert(ex == "******+0.0000000000000000");
   13653                                     assert(ios.width() == 0);
   13654                                 }
   13655                                 ios.width(25);
   13656                                 internal(ios);
   13657                                 {
   13658                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13659                                     std::string ex(str, iter.base());
   13660                                     assert(ex == "+******0.0000000000000000");
   13661                                     assert(ios.width() == 0);
   13662                                 }
   13663                             }
   13664                             ios.imbue(lg);
   13665                             {
   13666                                 ios.width(0);
   13667                                 {
   13668                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13669                                     std::string ex(str, iter.base());
   13670                                     assert(ex == "+0;0000000000000000");
   13671                                     assert(ios.width() == 0);
   13672                                 }
   13673                                 ios.width(25);
   13674                                 left(ios);
   13675                                 {
   13676                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13677                                     std::string ex(str, iter.base());
   13678                                     assert(ex == "+0;0000000000000000******");
   13679                                     assert(ios.width() == 0);
   13680                                 }
   13681                                 ios.width(25);
   13682                                 right(ios);
   13683                                 {
   13684                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13685                                     std::string ex(str, iter.base());
   13686                                     assert(ex == "******+0;0000000000000000");
   13687                                     assert(ios.width() == 0);
   13688                                 }
   13689                                 ios.width(25);
   13690                                 internal(ios);
   13691                                 {
   13692                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13693                                     std::string ex(str, iter.base());
   13694                                     assert(ex == "+******0;0000000000000000");
   13695                                     assert(ios.width() == 0);
   13696                                 }
   13697                             }
   13698                         }
   13699                     }
   13700                 }
   13701             }
   13702             ios.precision(60);
   13703             {
   13704                 nouppercase(ios);
   13705                 {
   13706                     noshowpos(ios);
   13707                     {
   13708                         noshowpoint(ios);
   13709                         {
   13710                             ios.imbue(lc);
   13711                             {
   13712                                 ios.width(0);
   13713                                 {
   13714                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13715                                     std::string ex(str, iter.base());
   13716                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   13717                                     assert(ios.width() == 0);
   13718                                 }
   13719                                 ios.width(25);
   13720                                 left(ios);
   13721                                 {
   13722                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13723                                     std::string ex(str, iter.base());
   13724                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   13725                                     assert(ios.width() == 0);
   13726                                 }
   13727                                 ios.width(25);
   13728                                 right(ios);
   13729                                 {
   13730                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13731                                     std::string ex(str, iter.base());
   13732                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   13733                                     assert(ios.width() == 0);
   13734                                 }
   13735                                 ios.width(25);
   13736                                 internal(ios);
   13737                                 {
   13738                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13739                                     std::string ex(str, iter.base());
   13740                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   13741                                     assert(ios.width() == 0);
   13742                                 }
   13743                             }
   13744                             ios.imbue(lg);
   13745                             {
   13746                                 ios.width(0);
   13747                                 {
   13748                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13749                                     std::string ex(str, iter.base());
   13750                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   13751                                     assert(ios.width() == 0);
   13752                                 }
   13753                                 ios.width(25);
   13754                                 left(ios);
   13755                                 {
   13756                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13757                                     std::string ex(str, iter.base());
   13758                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   13759                                     assert(ios.width() == 0);
   13760                                 }
   13761                                 ios.width(25);
   13762                                 right(ios);
   13763                                 {
   13764                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13765                                     std::string ex(str, iter.base());
   13766                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   13767                                     assert(ios.width() == 0);
   13768                                 }
   13769                                 ios.width(25);
   13770                                 internal(ios);
   13771                                 {
   13772                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13773                                     std::string ex(str, iter.base());
   13774                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   13775                                     assert(ios.width() == 0);
   13776                                 }
   13777                             }
   13778                         }
   13779                         showpoint(ios);
   13780                         {
   13781                             ios.imbue(lc);
   13782                             {
   13783                                 ios.width(0);
   13784                                 {
   13785                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13786                                     std::string ex(str, iter.base());
   13787                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   13788                                     assert(ios.width() == 0);
   13789                                 }
   13790                                 ios.width(25);
   13791                                 left(ios);
   13792                                 {
   13793                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13794                                     std::string ex(str, iter.base());
   13795                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   13796                                     assert(ios.width() == 0);
   13797                                 }
   13798                                 ios.width(25);
   13799                                 right(ios);
   13800                                 {
   13801                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13802                                     std::string ex(str, iter.base());
   13803                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   13804                                     assert(ios.width() == 0);
   13805                                 }
   13806                                 ios.width(25);
   13807                                 internal(ios);
   13808                                 {
   13809                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13810                                     std::string ex(str, iter.base());
   13811                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   13812                                     assert(ios.width() == 0);
   13813                                 }
   13814                             }
   13815                             ios.imbue(lg);
   13816                             {
   13817                                 ios.width(0);
   13818                                 {
   13819                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13820                                     std::string ex(str, iter.base());
   13821                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   13822                                     assert(ios.width() == 0);
   13823                                 }
   13824                                 ios.width(25);
   13825                                 left(ios);
   13826                                 {
   13827                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13828                                     std::string ex(str, iter.base());
   13829                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   13830                                     assert(ios.width() == 0);
   13831                                 }
   13832                                 ios.width(25);
   13833                                 right(ios);
   13834                                 {
   13835                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13836                                     std::string ex(str, iter.base());
   13837                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   13838                                     assert(ios.width() == 0);
   13839                                 }
   13840                                 ios.width(25);
   13841                                 internal(ios);
   13842                                 {
   13843                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13844                                     std::string ex(str, iter.base());
   13845                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   13846                                     assert(ios.width() == 0);
   13847                                 }
   13848                             }
   13849                         }
   13850                     }
   13851                     showpos(ios);
   13852                     {
   13853                         noshowpoint(ios);
   13854                         {
   13855                             ios.imbue(lc);
   13856                             {
   13857                                 ios.width(0);
   13858                                 {
   13859                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13860                                     std::string ex(str, iter.base());
   13861                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   13862                                     assert(ios.width() == 0);
   13863                                 }
   13864                                 ios.width(25);
   13865                                 left(ios);
   13866                                 {
   13867                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13868                                     std::string ex(str, iter.base());
   13869                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   13870                                     assert(ios.width() == 0);
   13871                                 }
   13872                                 ios.width(25);
   13873                                 right(ios);
   13874                                 {
   13875                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13876                                     std::string ex(str, iter.base());
   13877                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   13878                                     assert(ios.width() == 0);
   13879                                 }
   13880                                 ios.width(25);
   13881                                 internal(ios);
   13882                                 {
   13883                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13884                                     std::string ex(str, iter.base());
   13885                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   13886                                     assert(ios.width() == 0);
   13887                                 }
   13888                             }
   13889                             ios.imbue(lg);
   13890                             {
   13891                                 ios.width(0);
   13892                                 {
   13893                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13894                                     std::string ex(str, iter.base());
   13895                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   13896                                     assert(ios.width() == 0);
   13897                                 }
   13898                                 ios.width(25);
   13899                                 left(ios);
   13900                                 {
   13901                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13902                                     std::string ex(str, iter.base());
   13903                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   13904                                     assert(ios.width() == 0);
   13905                                 }
   13906                                 ios.width(25);
   13907                                 right(ios);
   13908                                 {
   13909                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13910                                     std::string ex(str, iter.base());
   13911                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   13912                                     assert(ios.width() == 0);
   13913                                 }
   13914                                 ios.width(25);
   13915                                 internal(ios);
   13916                                 {
   13917                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13918                                     std::string ex(str, iter.base());
   13919                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   13920                                     assert(ios.width() == 0);
   13921                                 }
   13922                             }
   13923                         }
   13924                         showpoint(ios);
   13925                         {
   13926                             ios.imbue(lc);
   13927                             {
   13928                                 ios.width(0);
   13929                                 {
   13930                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13931                                     std::string ex(str, iter.base());
   13932                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   13933                                     assert(ios.width() == 0);
   13934                                 }
   13935                                 ios.width(25);
   13936                                 left(ios);
   13937                                 {
   13938                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13939                                     std::string ex(str, iter.base());
   13940                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   13941                                     assert(ios.width() == 0);
   13942                                 }
   13943                                 ios.width(25);
   13944                                 right(ios);
   13945                                 {
   13946                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13947                                     std::string ex(str, iter.base());
   13948                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   13949                                     assert(ios.width() == 0);
   13950                                 }
   13951                                 ios.width(25);
   13952                                 internal(ios);
   13953                                 {
   13954                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13955                                     std::string ex(str, iter.base());
   13956                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   13957                                     assert(ios.width() == 0);
   13958                                 }
   13959                             }
   13960                             ios.imbue(lg);
   13961                             {
   13962                                 ios.width(0);
   13963                                 {
   13964                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13965                                     std::string ex(str, iter.base());
   13966                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   13967                                     assert(ios.width() == 0);
   13968                                 }
   13969                                 ios.width(25);
   13970                                 left(ios);
   13971                                 {
   13972                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13973                                     std::string ex(str, iter.base());
   13974                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   13975                                     assert(ios.width() == 0);
   13976                                 }
   13977                                 ios.width(25);
   13978                                 right(ios);
   13979                                 {
   13980                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13981                                     std::string ex(str, iter.base());
   13982                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   13983                                     assert(ios.width() == 0);
   13984                                 }
   13985                                 ios.width(25);
   13986                                 internal(ios);
   13987                                 {
   13988                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13989                                     std::string ex(str, iter.base());
   13990                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   13991                                     assert(ios.width() == 0);
   13992                                 }
   13993                             }
   13994                         }
   13995                     }
   13996                 }
   13997                 uppercase(ios);
   13998                 {
   13999                     noshowpos(ios);
   14000                     {
   14001                         noshowpoint(ios);
   14002                         {
   14003                             ios.imbue(lc);
   14004                             {
   14005                                 ios.width(0);
   14006                                 {
   14007                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14008                                     std::string ex(str, iter.base());
   14009                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   14010                                     assert(ios.width() == 0);
   14011                                 }
   14012                                 ios.width(25);
   14013                                 left(ios);
   14014                                 {
   14015                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14016                                     std::string ex(str, iter.base());
   14017                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   14018                                     assert(ios.width() == 0);
   14019                                 }
   14020                                 ios.width(25);
   14021                                 right(ios);
   14022                                 {
   14023                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14024                                     std::string ex(str, iter.base());
   14025                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   14026                                     assert(ios.width() == 0);
   14027                                 }
   14028                                 ios.width(25);
   14029                                 internal(ios);
   14030                                 {
   14031                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14032                                     std::string ex(str, iter.base());
   14033                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   14034                                     assert(ios.width() == 0);
   14035                                 }
   14036                             }
   14037                             ios.imbue(lg);
   14038                             {
   14039                                 ios.width(0);
   14040                                 {
   14041                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14042                                     std::string ex(str, iter.base());
   14043                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   14044                                     assert(ios.width() == 0);
   14045                                 }
   14046                                 ios.width(25);
   14047                                 left(ios);
   14048                                 {
   14049                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14050                                     std::string ex(str, iter.base());
   14051                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   14052                                     assert(ios.width() == 0);
   14053                                 }
   14054                                 ios.width(25);
   14055                                 right(ios);
   14056                                 {
   14057                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14058                                     std::string ex(str, iter.base());
   14059                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   14060                                     assert(ios.width() == 0);
   14061                                 }
   14062                                 ios.width(25);
   14063                                 internal(ios);
   14064                                 {
   14065                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14066                                     std::string ex(str, iter.base());
   14067                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   14068                                     assert(ios.width() == 0);
   14069                                 }
   14070                             }
   14071                         }
   14072                         showpoint(ios);
   14073                         {
   14074                             ios.imbue(lc);
   14075                             {
   14076                                 ios.width(0);
   14077                                 {
   14078                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14079                                     std::string ex(str, iter.base());
   14080                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   14081                                     assert(ios.width() == 0);
   14082                                 }
   14083                                 ios.width(25);
   14084                                 left(ios);
   14085                                 {
   14086                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14087                                     std::string ex(str, iter.base());
   14088                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   14089                                     assert(ios.width() == 0);
   14090                                 }
   14091                                 ios.width(25);
   14092                                 right(ios);
   14093                                 {
   14094                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14095                                     std::string ex(str, iter.base());
   14096                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   14097                                     assert(ios.width() == 0);
   14098                                 }
   14099                                 ios.width(25);
   14100                                 internal(ios);
   14101                                 {
   14102                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14103                                     std::string ex(str, iter.base());
   14104                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   14105                                     assert(ios.width() == 0);
   14106                                 }
   14107                             }
   14108                             ios.imbue(lg);
   14109                             {
   14110                                 ios.width(0);
   14111                                 {
   14112                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14113                                     std::string ex(str, iter.base());
   14114                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   14115                                     assert(ios.width() == 0);
   14116                                 }
   14117                                 ios.width(25);
   14118                                 left(ios);
   14119                                 {
   14120                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14121                                     std::string ex(str, iter.base());
   14122                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   14123                                     assert(ios.width() == 0);
   14124                                 }
   14125                                 ios.width(25);
   14126                                 right(ios);
   14127                                 {
   14128                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14129                                     std::string ex(str, iter.base());
   14130                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   14131                                     assert(ios.width() == 0);
   14132                                 }
   14133                                 ios.width(25);
   14134                                 internal(ios);
   14135                                 {
   14136                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14137                                     std::string ex(str, iter.base());
   14138                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   14139                                     assert(ios.width() == 0);
   14140                                 }
   14141                             }
   14142                         }
   14143                     }
   14144                     showpos(ios);
   14145                     {
   14146                         noshowpoint(ios);
   14147                         {
   14148                             ios.imbue(lc);
   14149                             {
   14150                                 ios.width(0);
   14151                                 {
   14152                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14153                                     std::string ex(str, iter.base());
   14154                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   14155                                     assert(ios.width() == 0);
   14156                                 }
   14157                                 ios.width(25);
   14158                                 left(ios);
   14159                                 {
   14160                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14161                                     std::string ex(str, iter.base());
   14162                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   14163                                     assert(ios.width() == 0);
   14164                                 }
   14165                                 ios.width(25);
   14166                                 right(ios);
   14167                                 {
   14168                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14169                                     std::string ex(str, iter.base());
   14170                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   14171                                     assert(ios.width() == 0);
   14172                                 }
   14173                                 ios.width(25);
   14174                                 internal(ios);
   14175                                 {
   14176                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14177                                     std::string ex(str, iter.base());
   14178                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   14179                                     assert(ios.width() == 0);
   14180                                 }
   14181                             }
   14182                             ios.imbue(lg);
   14183                             {
   14184                                 ios.width(0);
   14185                                 {
   14186                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14187                                     std::string ex(str, iter.base());
   14188                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   14189                                     assert(ios.width() == 0);
   14190                                 }
   14191                                 ios.width(25);
   14192                                 left(ios);
   14193                                 {
   14194                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14195                                     std::string ex(str, iter.base());
   14196                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   14197                                     assert(ios.width() == 0);
   14198                                 }
   14199                                 ios.width(25);
   14200                                 right(ios);
   14201                                 {
   14202                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14203                                     std::string ex(str, iter.base());
   14204                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   14205                                     assert(ios.width() == 0);
   14206                                 }
   14207                                 ios.width(25);
   14208                                 internal(ios);
   14209                                 {
   14210                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14211                                     std::string ex(str, iter.base());
   14212                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   14213                                     assert(ios.width() == 0);
   14214                                 }
   14215                             }
   14216                         }
   14217                         showpoint(ios);
   14218                         {
   14219                             ios.imbue(lc);
   14220                             {
   14221                                 ios.width(0);
   14222                                 {
   14223                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14224                                     std::string ex(str, iter.base());
   14225                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   14226                                     assert(ios.width() == 0);
   14227                                 }
   14228                                 ios.width(25);
   14229                                 left(ios);
   14230                                 {
   14231                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14232                                     std::string ex(str, iter.base());
   14233                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   14234                                     assert(ios.width() == 0);
   14235                                 }
   14236                                 ios.width(25);
   14237                                 right(ios);
   14238                                 {
   14239                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14240                                     std::string ex(str, iter.base());
   14241                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   14242                                     assert(ios.width() == 0);
   14243                                 }
   14244                                 ios.width(25);
   14245                                 internal(ios);
   14246                                 {
   14247                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14248                                     std::string ex(str, iter.base());
   14249                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   14250                                     assert(ios.width() == 0);
   14251                                 }
   14252                             }
   14253                             ios.imbue(lg);
   14254                             {
   14255                                 ios.width(0);
   14256                                 {
   14257                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14258                                     std::string ex(str, iter.base());
   14259                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   14260                                     assert(ios.width() == 0);
   14261                                 }
   14262                                 ios.width(25);
   14263                                 left(ios);
   14264                                 {
   14265                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14266                                     std::string ex(str, iter.base());
   14267                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   14268                                     assert(ios.width() == 0);
   14269                                 }
   14270                                 ios.width(25);
   14271                                 right(ios);
   14272                                 {
   14273                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14274                                     std::string ex(str, iter.base());
   14275                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   14276                                     assert(ios.width() == 0);
   14277                                 }
   14278                                 ios.width(25);
   14279                                 internal(ios);
   14280                                 {
   14281                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14282                                     std::string ex(str, iter.base());
   14283                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   14284                                     assert(ios.width() == 0);
   14285                                 }
   14286                             }
   14287                         }
   14288                     }
   14289                 }
   14290             }
   14291         }
   14292     }
   14293 }
   14294 
   14295 void test7()
   14296 {
   14297     char str[200];
   14298     output_iterator<char*> iter;
   14299     std::locale lc = std::locale::classic();
   14300     std::locale lg(lc, new my_numpunct);
   14301     const my_facet f(1);
   14302     {
   14303         long double v = -0.;
   14304         std::ios ios(0);
   14305         fixed(ios);
   14306         // %f
   14307         {
   14308             ios.precision(0);
   14309             {
   14310                 nouppercase(ios);
   14311                 {
   14312                     noshowpos(ios);
   14313                     {
   14314                         noshowpoint(ios);
   14315                         {
   14316                             ios.imbue(lc);
   14317                             {
   14318                                 ios.width(0);
   14319                                 {
   14320                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14321                                     std::string ex(str, iter.base());
   14322                                     assert(ex == "-0");
   14323                                     assert(ios.width() == 0);
   14324                                 }
   14325                                 ios.width(25);
   14326                                 left(ios);
   14327                                 {
   14328                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14329                                     std::string ex(str, iter.base());
   14330                                     assert(ex == "-0***********************");
   14331                                     assert(ios.width() == 0);
   14332                                 }
   14333                                 ios.width(25);
   14334                                 right(ios);
   14335                                 {
   14336                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14337                                     std::string ex(str, iter.base());
   14338                                     assert(ex == "***********************-0");
   14339                                     assert(ios.width() == 0);
   14340                                 }
   14341                                 ios.width(25);
   14342                                 internal(ios);
   14343                                 {
   14344                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14345                                     std::string ex(str, iter.base());
   14346                                     assert(ex == "-***********************0");
   14347                                     assert(ios.width() == 0);
   14348                                 }
   14349                             }
   14350                             ios.imbue(lg);
   14351                             {
   14352                                 ios.width(0);
   14353                                 {
   14354                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14355                                     std::string ex(str, iter.base());
   14356                                     assert(ex == "-0");
   14357                                     assert(ios.width() == 0);
   14358                                 }
   14359                                 ios.width(25);
   14360                                 left(ios);
   14361                                 {
   14362                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14363                                     std::string ex(str, iter.base());
   14364                                     assert(ex == "-0***********************");
   14365                                     assert(ios.width() == 0);
   14366                                 }
   14367                                 ios.width(25);
   14368                                 right(ios);
   14369                                 {
   14370                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14371                                     std::string ex(str, iter.base());
   14372                                     assert(ex == "***********************-0");
   14373                                     assert(ios.width() == 0);
   14374                                 }
   14375                                 ios.width(25);
   14376                                 internal(ios);
   14377                                 {
   14378                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14379                                     std::string ex(str, iter.base());
   14380                                     assert(ex == "-***********************0");
   14381                                     assert(ios.width() == 0);
   14382                                 }
   14383                             }
   14384                         }
   14385                         showpoint(ios);
   14386                         {
   14387                             ios.imbue(lc);
   14388                             {
   14389                                 ios.width(0);
   14390                                 {
   14391                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14392                                     std::string ex(str, iter.base());
   14393                                     assert(ex == "-0.");
   14394                                     assert(ios.width() == 0);
   14395                                 }
   14396                                 ios.width(25);
   14397                                 left(ios);
   14398                                 {
   14399                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14400                                     std::string ex(str, iter.base());
   14401                                     assert(ex == "-0.**********************");
   14402                                     assert(ios.width() == 0);
   14403                                 }
   14404                                 ios.width(25);
   14405                                 right(ios);
   14406                                 {
   14407                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14408                                     std::string ex(str, iter.base());
   14409                                     assert(ex == "**********************-0.");
   14410                                     assert(ios.width() == 0);
   14411                                 }
   14412                                 ios.width(25);
   14413                                 internal(ios);
   14414                                 {
   14415                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14416                                     std::string ex(str, iter.base());
   14417                                     assert(ex == "-**********************0.");
   14418                                     assert(ios.width() == 0);
   14419                                 }
   14420                             }
   14421                             ios.imbue(lg);
   14422                             {
   14423                                 ios.width(0);
   14424                                 {
   14425                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14426                                     std::string ex(str, iter.base());
   14427                                     assert(ex == "-0;");
   14428                                     assert(ios.width() == 0);
   14429                                 }
   14430                                 ios.width(25);
   14431                                 left(ios);
   14432                                 {
   14433                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14434                                     std::string ex(str, iter.base());
   14435                                     assert(ex == "-0;**********************");
   14436                                     assert(ios.width() == 0);
   14437                                 }
   14438                                 ios.width(25);
   14439                                 right(ios);
   14440                                 {
   14441                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14442                                     std::string ex(str, iter.base());
   14443                                     assert(ex == "**********************-0;");
   14444                                     assert(ios.width() == 0);
   14445                                 }
   14446                                 ios.width(25);
   14447                                 internal(ios);
   14448                                 {
   14449                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14450                                     std::string ex(str, iter.base());
   14451                                     assert(ex == "-**********************0;");
   14452                                     assert(ios.width() == 0);
   14453                                 }
   14454                             }
   14455                         }
   14456                     }
   14457                     showpos(ios);
   14458                     {
   14459                         noshowpoint(ios);
   14460                         {
   14461                             ios.imbue(lc);
   14462                             {
   14463                                 ios.width(0);
   14464                                 {
   14465                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14466                                     std::string ex(str, iter.base());
   14467                                     assert(ex == "-0");
   14468                                     assert(ios.width() == 0);
   14469                                 }
   14470                                 ios.width(25);
   14471                                 left(ios);
   14472                                 {
   14473                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14474                                     std::string ex(str, iter.base());
   14475                                     assert(ex == "-0***********************");
   14476                                     assert(ios.width() == 0);
   14477                                 }
   14478                                 ios.width(25);
   14479                                 right(ios);
   14480                                 {
   14481                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14482                                     std::string ex(str, iter.base());
   14483                                     assert(ex == "***********************-0");
   14484                                     assert(ios.width() == 0);
   14485                                 }
   14486                                 ios.width(25);
   14487                                 internal(ios);
   14488                                 {
   14489                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14490                                     std::string ex(str, iter.base());
   14491                                     assert(ex == "-***********************0");
   14492                                     assert(ios.width() == 0);
   14493                                 }
   14494                             }
   14495                             ios.imbue(lg);
   14496                             {
   14497                                 ios.width(0);
   14498                                 {
   14499                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14500                                     std::string ex(str, iter.base());
   14501                                     assert(ex == "-0");
   14502                                     assert(ios.width() == 0);
   14503                                 }
   14504                                 ios.width(25);
   14505                                 left(ios);
   14506                                 {
   14507                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14508                                     std::string ex(str, iter.base());
   14509                                     assert(ex == "-0***********************");
   14510                                     assert(ios.width() == 0);
   14511                                 }
   14512                                 ios.width(25);
   14513                                 right(ios);
   14514                                 {
   14515                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14516                                     std::string ex(str, iter.base());
   14517                                     assert(ex == "***********************-0");
   14518                                     assert(ios.width() == 0);
   14519                                 }
   14520                                 ios.width(25);
   14521                                 internal(ios);
   14522                                 {
   14523                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14524                                     std::string ex(str, iter.base());
   14525                                     assert(ex == "-***********************0");
   14526                                     assert(ios.width() == 0);
   14527                                 }
   14528                             }
   14529                         }
   14530                         showpoint(ios);
   14531                         {
   14532                             ios.imbue(lc);
   14533                             {
   14534                                 ios.width(0);
   14535                                 {
   14536                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14537                                     std::string ex(str, iter.base());
   14538                                     assert(ex == "-0.");
   14539                                     assert(ios.width() == 0);
   14540                                 }
   14541                                 ios.width(25);
   14542                                 left(ios);
   14543                                 {
   14544                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14545                                     std::string ex(str, iter.base());
   14546                                     assert(ex == "-0.**********************");
   14547                                     assert(ios.width() == 0);
   14548                                 }
   14549                                 ios.width(25);
   14550                                 right(ios);
   14551                                 {
   14552                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14553                                     std::string ex(str, iter.base());
   14554                                     assert(ex == "**********************-0.");
   14555                                     assert(ios.width() == 0);
   14556                                 }
   14557                                 ios.width(25);
   14558                                 internal(ios);
   14559                                 {
   14560                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14561                                     std::string ex(str, iter.base());
   14562                                     assert(ex == "-**********************0.");
   14563                                     assert(ios.width() == 0);
   14564                                 }
   14565                             }
   14566                             ios.imbue(lg);
   14567                             {
   14568                                 ios.width(0);
   14569                                 {
   14570                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14571                                     std::string ex(str, iter.base());
   14572                                     assert(ex == "-0;");
   14573                                     assert(ios.width() == 0);
   14574                                 }
   14575                                 ios.width(25);
   14576                                 left(ios);
   14577                                 {
   14578                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14579                                     std::string ex(str, iter.base());
   14580                                     assert(ex == "-0;**********************");
   14581                                     assert(ios.width() == 0);
   14582                                 }
   14583                                 ios.width(25);
   14584                                 right(ios);
   14585                                 {
   14586                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14587                                     std::string ex(str, iter.base());
   14588                                     assert(ex == "**********************-0;");
   14589                                     assert(ios.width() == 0);
   14590                                 }
   14591                                 ios.width(25);
   14592                                 internal(ios);
   14593                                 {
   14594                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14595                                     std::string ex(str, iter.base());
   14596                                     assert(ex == "-**********************0;");
   14597                                     assert(ios.width() == 0);
   14598                                 }
   14599                             }
   14600                         }
   14601                     }
   14602                 }
   14603                 uppercase(ios);
   14604                 {
   14605                     noshowpos(ios);
   14606                     {
   14607                         noshowpoint(ios);
   14608                         {
   14609                             ios.imbue(lc);
   14610                             {
   14611                                 ios.width(0);
   14612                                 {
   14613                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14614                                     std::string ex(str, iter.base());
   14615                                     assert(ex == "-0");
   14616                                     assert(ios.width() == 0);
   14617                                 }
   14618                                 ios.width(25);
   14619                                 left(ios);
   14620                                 {
   14621                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14622                                     std::string ex(str, iter.base());
   14623                                     assert(ex == "-0***********************");
   14624                                     assert(ios.width() == 0);
   14625                                 }
   14626                                 ios.width(25);
   14627                                 right(ios);
   14628                                 {
   14629                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14630                                     std::string ex(str, iter.base());
   14631                                     assert(ex == "***********************-0");
   14632                                     assert(ios.width() == 0);
   14633                                 }
   14634                                 ios.width(25);
   14635                                 internal(ios);
   14636                                 {
   14637                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14638                                     std::string ex(str, iter.base());
   14639                                     assert(ex == "-***********************0");
   14640                                     assert(ios.width() == 0);
   14641                                 }
   14642                             }
   14643                             ios.imbue(lg);
   14644                             {
   14645                                 ios.width(0);
   14646                                 {
   14647                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14648                                     std::string ex(str, iter.base());
   14649                                     assert(ex == "-0");
   14650                                     assert(ios.width() == 0);
   14651                                 }
   14652                                 ios.width(25);
   14653                                 left(ios);
   14654                                 {
   14655                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14656                                     std::string ex(str, iter.base());
   14657                                     assert(ex == "-0***********************");
   14658                                     assert(ios.width() == 0);
   14659                                 }
   14660                                 ios.width(25);
   14661                                 right(ios);
   14662                                 {
   14663                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14664                                     std::string ex(str, iter.base());
   14665                                     assert(ex == "***********************-0");
   14666                                     assert(ios.width() == 0);
   14667                                 }
   14668                                 ios.width(25);
   14669                                 internal(ios);
   14670                                 {
   14671                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14672                                     std::string ex(str, iter.base());
   14673                                     assert(ex == "-***********************0");
   14674                                     assert(ios.width() == 0);
   14675                                 }
   14676                             }
   14677                         }
   14678                         showpoint(ios);
   14679                         {
   14680                             ios.imbue(lc);
   14681                             {
   14682                                 ios.width(0);
   14683                                 {
   14684                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14685                                     std::string ex(str, iter.base());
   14686                                     assert(ex == "-0.");
   14687                                     assert(ios.width() == 0);
   14688                                 }
   14689                                 ios.width(25);
   14690                                 left(ios);
   14691                                 {
   14692                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14693                                     std::string ex(str, iter.base());
   14694                                     assert(ex == "-0.**********************");
   14695                                     assert(ios.width() == 0);
   14696                                 }
   14697                                 ios.width(25);
   14698                                 right(ios);
   14699                                 {
   14700                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14701                                     std::string ex(str, iter.base());
   14702                                     assert(ex == "**********************-0.");
   14703                                     assert(ios.width() == 0);
   14704                                 }
   14705                                 ios.width(25);
   14706                                 internal(ios);
   14707                                 {
   14708                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14709                                     std::string ex(str, iter.base());
   14710                                     assert(ex == "-**********************0.");
   14711                                     assert(ios.width() == 0);
   14712                                 }
   14713                             }
   14714                             ios.imbue(lg);
   14715                             {
   14716                                 ios.width(0);
   14717                                 {
   14718                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14719                                     std::string ex(str, iter.base());
   14720                                     assert(ex == "-0;");
   14721                                     assert(ios.width() == 0);
   14722                                 }
   14723                                 ios.width(25);
   14724                                 left(ios);
   14725                                 {
   14726                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14727                                     std::string ex(str, iter.base());
   14728                                     assert(ex == "-0;**********************");
   14729                                     assert(ios.width() == 0);
   14730                                 }
   14731                                 ios.width(25);
   14732                                 right(ios);
   14733                                 {
   14734                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14735                                     std::string ex(str, iter.base());
   14736                                     assert(ex == "**********************-0;");
   14737                                     assert(ios.width() == 0);
   14738                                 }
   14739                                 ios.width(25);
   14740                                 internal(ios);
   14741                                 {
   14742                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14743                                     std::string ex(str, iter.base());
   14744                                     assert(ex == "-**********************0;");
   14745                                     assert(ios.width() == 0);
   14746                                 }
   14747                             }
   14748                         }
   14749                     }
   14750                     showpos(ios);
   14751                     {
   14752                         noshowpoint(ios);
   14753                         {
   14754                             ios.imbue(lc);
   14755                             {
   14756                                 ios.width(0);
   14757                                 {
   14758                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14759                                     std::string ex(str, iter.base());
   14760                                     assert(ex == "-0");
   14761                                     assert(ios.width() == 0);
   14762                                 }
   14763                                 ios.width(25);
   14764                                 left(ios);
   14765                                 {
   14766                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14767                                     std::string ex(str, iter.base());
   14768                                     assert(ex == "-0***********************");
   14769                                     assert(ios.width() == 0);
   14770                                 }
   14771                                 ios.width(25);
   14772                                 right(ios);
   14773                                 {
   14774                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14775                                     std::string ex(str, iter.base());
   14776                                     assert(ex == "***********************-0");
   14777                                     assert(ios.width() == 0);
   14778                                 }
   14779                                 ios.width(25);
   14780                                 internal(ios);
   14781                                 {
   14782                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14783                                     std::string ex(str, iter.base());
   14784                                     assert(ex == "-***********************0");
   14785                                     assert(ios.width() == 0);
   14786                                 }
   14787                             }
   14788                             ios.imbue(lg);
   14789                             {
   14790                                 ios.width(0);
   14791                                 {
   14792                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14793                                     std::string ex(str, iter.base());
   14794                                     assert(ex == "-0");
   14795                                     assert(ios.width() == 0);
   14796                                 }
   14797                                 ios.width(25);
   14798                                 left(ios);
   14799                                 {
   14800                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14801                                     std::string ex(str, iter.base());
   14802                                     assert(ex == "-0***********************");
   14803                                     assert(ios.width() == 0);
   14804                                 }
   14805                                 ios.width(25);
   14806                                 right(ios);
   14807                                 {
   14808                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14809                                     std::string ex(str, iter.base());
   14810                                     assert(ex == "***********************-0");
   14811                                     assert(ios.width() == 0);
   14812                                 }
   14813                                 ios.width(25);
   14814                                 internal(ios);
   14815                                 {
   14816                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14817                                     std::string ex(str, iter.base());
   14818                                     assert(ex == "-***********************0");
   14819                                     assert(ios.width() == 0);
   14820                                 }
   14821                             }
   14822                         }
   14823                         showpoint(ios);
   14824                         {
   14825                             ios.imbue(lc);
   14826                             {
   14827                                 ios.width(0);
   14828                                 {
   14829                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14830                                     std::string ex(str, iter.base());
   14831                                     assert(ex == "-0.");
   14832                                     assert(ios.width() == 0);
   14833                                 }
   14834                                 ios.width(25);
   14835                                 left(ios);
   14836                                 {
   14837                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14838                                     std::string ex(str, iter.base());
   14839                                     assert(ex == "-0.**********************");
   14840                                     assert(ios.width() == 0);
   14841                                 }
   14842                                 ios.width(25);
   14843                                 right(ios);
   14844                                 {
   14845                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14846                                     std::string ex(str, iter.base());
   14847                                     assert(ex == "**********************-0.");
   14848                                     assert(ios.width() == 0);
   14849                                 }
   14850                                 ios.width(25);
   14851                                 internal(ios);
   14852                                 {
   14853                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14854                                     std::string ex(str, iter.base());
   14855                                     assert(ex == "-**********************0.");
   14856                                     assert(ios.width() == 0);
   14857                                 }
   14858                             }
   14859                             ios.imbue(lg);
   14860                             {
   14861                                 ios.width(0);
   14862                                 {
   14863                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14864                                     std::string ex(str, iter.base());
   14865                                     assert(ex == "-0;");
   14866                                     assert(ios.width() == 0);
   14867                                 }
   14868                                 ios.width(25);
   14869                                 left(ios);
   14870                                 {
   14871                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14872                                     std::string ex(str, iter.base());
   14873                                     assert(ex == "-0;**********************");
   14874                                     assert(ios.width() == 0);
   14875                                 }
   14876                                 ios.width(25);
   14877                                 right(ios);
   14878                                 {
   14879                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14880                                     std::string ex(str, iter.base());
   14881                                     assert(ex == "**********************-0;");
   14882                                     assert(ios.width() == 0);
   14883                                 }
   14884                                 ios.width(25);
   14885                                 internal(ios);
   14886                                 {
   14887                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14888                                     std::string ex(str, iter.base());
   14889                                     assert(ex == "-**********************0;");
   14890                                     assert(ios.width() == 0);
   14891                                 }
   14892                             }
   14893                         }
   14894                     }
   14895                 }
   14896             }
   14897             ios.precision(1);
   14898             {
   14899                 nouppercase(ios);
   14900                 {
   14901                     noshowpos(ios);
   14902                     {
   14903                         noshowpoint(ios);
   14904                         {
   14905                             ios.imbue(lc);
   14906                             {
   14907                                 ios.width(0);
   14908                                 {
   14909                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14910                                     std::string ex(str, iter.base());
   14911                                     assert(ex == "-0.0");
   14912                                     assert(ios.width() == 0);
   14913                                 }
   14914                                 ios.width(25);
   14915                                 left(ios);
   14916                                 {
   14917                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14918                                     std::string ex(str, iter.base());
   14919                                     assert(ex == "-0.0*********************");
   14920                                     assert(ios.width() == 0);
   14921                                 }
   14922                                 ios.width(25);
   14923                                 right(ios);
   14924                                 {
   14925                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14926                                     std::string ex(str, iter.base());
   14927                                     assert(ex == "*********************-0.0");
   14928                                     assert(ios.width() == 0);
   14929                                 }
   14930                                 ios.width(25);
   14931                                 internal(ios);
   14932                                 {
   14933                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14934                                     std::string ex(str, iter.base());
   14935                                     assert(ex == "-*********************0.0");
   14936                                     assert(ios.width() == 0);
   14937                                 }
   14938                             }
   14939                             ios.imbue(lg);
   14940                             {
   14941                                 ios.width(0);
   14942                                 {
   14943                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14944                                     std::string ex(str, iter.base());
   14945                                     assert(ex == "-0;0");
   14946                                     assert(ios.width() == 0);
   14947                                 }
   14948                                 ios.width(25);
   14949                                 left(ios);
   14950                                 {
   14951                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14952                                     std::string ex(str, iter.base());
   14953                                     assert(ex == "-0;0*********************");
   14954                                     assert(ios.width() == 0);
   14955                                 }
   14956                                 ios.width(25);
   14957                                 right(ios);
   14958                                 {
   14959                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14960                                     std::string ex(str, iter.base());
   14961                                     assert(ex == "*********************-0;0");
   14962                                     assert(ios.width() == 0);
   14963                                 }
   14964                                 ios.width(25);
   14965                                 internal(ios);
   14966                                 {
   14967                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14968                                     std::string ex(str, iter.base());
   14969                                     assert(ex == "-*********************0;0");
   14970                                     assert(ios.width() == 0);
   14971                                 }
   14972                             }
   14973                         }
   14974                         showpoint(ios);
   14975                         {
   14976                             ios.imbue(lc);
   14977                             {
   14978                                 ios.width(0);
   14979                                 {
   14980                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14981                                     std::string ex(str, iter.base());
   14982                                     assert(ex == "-0.0");
   14983                                     assert(ios.width() == 0);
   14984                                 }
   14985                                 ios.width(25);
   14986                                 left(ios);
   14987                                 {
   14988                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14989                                     std::string ex(str, iter.base());
   14990                                     assert(ex == "-0.0*********************");
   14991                                     assert(ios.width() == 0);
   14992                                 }
   14993                                 ios.width(25);
   14994                                 right(ios);
   14995                                 {
   14996                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14997                                     std::string ex(str, iter.base());
   14998                                     assert(ex == "*********************-0.0");
   14999                                     assert(ios.width() == 0);
   15000                                 }
   15001                                 ios.width(25);
   15002                                 internal(ios);
   15003                                 {
   15004                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15005                                     std::string ex(str, iter.base());
   15006                                     assert(ex == "-*********************0.0");
   15007                                     assert(ios.width() == 0);
   15008                                 }
   15009                             }
   15010                             ios.imbue(lg);
   15011                             {
   15012                                 ios.width(0);
   15013                                 {
   15014                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15015                                     std::string ex(str, iter.base());
   15016                                     assert(ex == "-0;0");
   15017                                     assert(ios.width() == 0);
   15018                                 }
   15019                                 ios.width(25);
   15020                                 left(ios);
   15021                                 {
   15022                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15023                                     std::string ex(str, iter.base());
   15024                                     assert(ex == "-0;0*********************");
   15025                                     assert(ios.width() == 0);
   15026                                 }
   15027                                 ios.width(25);
   15028                                 right(ios);
   15029                                 {
   15030                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15031                                     std::string ex(str, iter.base());
   15032                                     assert(ex == "*********************-0;0");
   15033                                     assert(ios.width() == 0);
   15034                                 }
   15035                                 ios.width(25);
   15036                                 internal(ios);
   15037                                 {
   15038                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15039                                     std::string ex(str, iter.base());
   15040                                     assert(ex == "-*********************0;0");
   15041                                     assert(ios.width() == 0);
   15042                                 }
   15043                             }
   15044                         }
   15045                     }
   15046                     showpos(ios);
   15047                     {
   15048                         noshowpoint(ios);
   15049                         {
   15050                             ios.imbue(lc);
   15051                             {
   15052                                 ios.width(0);
   15053                                 {
   15054                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15055                                     std::string ex(str, iter.base());
   15056                                     assert(ex == "-0.0");
   15057                                     assert(ios.width() == 0);
   15058                                 }
   15059                                 ios.width(25);
   15060                                 left(ios);
   15061                                 {
   15062                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15063                                     std::string ex(str, iter.base());
   15064                                     assert(ex == "-0.0*********************");
   15065                                     assert(ios.width() == 0);
   15066                                 }
   15067                                 ios.width(25);
   15068                                 right(ios);
   15069                                 {
   15070                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15071                                     std::string ex(str, iter.base());
   15072                                     assert(ex == "*********************-0.0");
   15073                                     assert(ios.width() == 0);
   15074                                 }
   15075                                 ios.width(25);
   15076                                 internal(ios);
   15077                                 {
   15078                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15079                                     std::string ex(str, iter.base());
   15080                                     assert(ex == "-*********************0.0");
   15081                                     assert(ios.width() == 0);
   15082                                 }
   15083                             }
   15084                             ios.imbue(lg);
   15085                             {
   15086                                 ios.width(0);
   15087                                 {
   15088                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15089                                     std::string ex(str, iter.base());
   15090                                     assert(ex == "-0;0");
   15091                                     assert(ios.width() == 0);
   15092                                 }
   15093                                 ios.width(25);
   15094                                 left(ios);
   15095                                 {
   15096                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15097                                     std::string ex(str, iter.base());
   15098                                     assert(ex == "-0;0*********************");
   15099                                     assert(ios.width() == 0);
   15100                                 }
   15101                                 ios.width(25);
   15102                                 right(ios);
   15103                                 {
   15104                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15105                                     std::string ex(str, iter.base());
   15106                                     assert(ex == "*********************-0;0");
   15107                                     assert(ios.width() == 0);
   15108                                 }
   15109                                 ios.width(25);
   15110                                 internal(ios);
   15111                                 {
   15112                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15113                                     std::string ex(str, iter.base());
   15114                                     assert(ex == "-*********************0;0");
   15115                                     assert(ios.width() == 0);
   15116                                 }
   15117                             }
   15118                         }
   15119                         showpoint(ios);
   15120                         {
   15121                             ios.imbue(lc);
   15122                             {
   15123                                 ios.width(0);
   15124                                 {
   15125                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15126                                     std::string ex(str, iter.base());
   15127                                     assert(ex == "-0.0");
   15128                                     assert(ios.width() == 0);
   15129                                 }
   15130                                 ios.width(25);
   15131                                 left(ios);
   15132                                 {
   15133                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15134                                     std::string ex(str, iter.base());
   15135                                     assert(ex == "-0.0*********************");
   15136                                     assert(ios.width() == 0);
   15137                                 }
   15138                                 ios.width(25);
   15139                                 right(ios);
   15140                                 {
   15141                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15142                                     std::string ex(str, iter.base());
   15143                                     assert(ex == "*********************-0.0");
   15144                                     assert(ios.width() == 0);
   15145                                 }
   15146                                 ios.width(25);
   15147                                 internal(ios);
   15148                                 {
   15149                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15150                                     std::string ex(str, iter.base());
   15151                                     assert(ex == "-*********************0.0");
   15152                                     assert(ios.width() == 0);
   15153                                 }
   15154                             }
   15155                             ios.imbue(lg);
   15156                             {
   15157                                 ios.width(0);
   15158                                 {
   15159                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15160                                     std::string ex(str, iter.base());
   15161                                     assert(ex == "-0;0");
   15162                                     assert(ios.width() == 0);
   15163                                 }
   15164                                 ios.width(25);
   15165                                 left(ios);
   15166                                 {
   15167                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15168                                     std::string ex(str, iter.base());
   15169                                     assert(ex == "-0;0*********************");
   15170                                     assert(ios.width() == 0);
   15171                                 }
   15172                                 ios.width(25);
   15173                                 right(ios);
   15174                                 {
   15175                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15176                                     std::string ex(str, iter.base());
   15177                                     assert(ex == "*********************-0;0");
   15178                                     assert(ios.width() == 0);
   15179                                 }
   15180                                 ios.width(25);
   15181                                 internal(ios);
   15182                                 {
   15183                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15184                                     std::string ex(str, iter.base());
   15185                                     assert(ex == "-*********************0;0");
   15186                                     assert(ios.width() == 0);
   15187                                 }
   15188                             }
   15189                         }
   15190                     }
   15191                 }
   15192                 uppercase(ios);
   15193                 {
   15194                     noshowpos(ios);
   15195                     {
   15196                         noshowpoint(ios);
   15197                         {
   15198                             ios.imbue(lc);
   15199                             {
   15200                                 ios.width(0);
   15201                                 {
   15202                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15203                                     std::string ex(str, iter.base());
   15204                                     assert(ex == "-0.0");
   15205                                     assert(ios.width() == 0);
   15206                                 }
   15207                                 ios.width(25);
   15208                                 left(ios);
   15209                                 {
   15210                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15211                                     std::string ex(str, iter.base());
   15212                                     assert(ex == "-0.0*********************");
   15213                                     assert(ios.width() == 0);
   15214                                 }
   15215                                 ios.width(25);
   15216                                 right(ios);
   15217                                 {
   15218                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15219                                     std::string ex(str, iter.base());
   15220                                     assert(ex == "*********************-0.0");
   15221                                     assert(ios.width() == 0);
   15222                                 }
   15223                                 ios.width(25);
   15224                                 internal(ios);
   15225                                 {
   15226                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15227                                     std::string ex(str, iter.base());
   15228                                     assert(ex == "-*********************0.0");
   15229                                     assert(ios.width() == 0);
   15230                                 }
   15231                             }
   15232                             ios.imbue(lg);
   15233                             {
   15234                                 ios.width(0);
   15235                                 {
   15236                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15237                                     std::string ex(str, iter.base());
   15238                                     assert(ex == "-0;0");
   15239                                     assert(ios.width() == 0);
   15240                                 }
   15241                                 ios.width(25);
   15242                                 left(ios);
   15243                                 {
   15244                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15245                                     std::string ex(str, iter.base());
   15246                                     assert(ex == "-0;0*********************");
   15247                                     assert(ios.width() == 0);
   15248                                 }
   15249                                 ios.width(25);
   15250                                 right(ios);
   15251                                 {
   15252                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15253                                     std::string ex(str, iter.base());
   15254                                     assert(ex == "*********************-0;0");
   15255                                     assert(ios.width() == 0);
   15256                                 }
   15257                                 ios.width(25);
   15258                                 internal(ios);
   15259                                 {
   15260                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15261                                     std::string ex(str, iter.base());
   15262                                     assert(ex == "-*********************0;0");
   15263                                     assert(ios.width() == 0);
   15264                                 }
   15265                             }
   15266                         }
   15267                         showpoint(ios);
   15268                         {
   15269                             ios.imbue(lc);
   15270                             {
   15271                                 ios.width(0);
   15272                                 {
   15273                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15274                                     std::string ex(str, iter.base());
   15275                                     assert(ex == "-0.0");
   15276                                     assert(ios.width() == 0);
   15277                                 }
   15278                                 ios.width(25);
   15279                                 left(ios);
   15280                                 {
   15281                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15282                                     std::string ex(str, iter.base());
   15283                                     assert(ex == "-0.0*********************");
   15284                                     assert(ios.width() == 0);
   15285                                 }
   15286                                 ios.width(25);
   15287                                 right(ios);
   15288                                 {
   15289                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15290                                     std::string ex(str, iter.base());
   15291                                     assert(ex == "*********************-0.0");
   15292                                     assert(ios.width() == 0);
   15293                                 }
   15294                                 ios.width(25);
   15295                                 internal(ios);
   15296                                 {
   15297                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15298                                     std::string ex(str, iter.base());
   15299                                     assert(ex == "-*********************0.0");
   15300                                     assert(ios.width() == 0);
   15301                                 }
   15302                             }
   15303                             ios.imbue(lg);
   15304                             {
   15305                                 ios.width(0);
   15306                                 {
   15307                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15308                                     std::string ex(str, iter.base());
   15309                                     assert(ex == "-0;0");
   15310                                     assert(ios.width() == 0);
   15311                                 }
   15312                                 ios.width(25);
   15313                                 left(ios);
   15314                                 {
   15315                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15316                                     std::string ex(str, iter.base());
   15317                                     assert(ex == "-0;0*********************");
   15318                                     assert(ios.width() == 0);
   15319                                 }
   15320                                 ios.width(25);
   15321                                 right(ios);
   15322                                 {
   15323                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15324                                     std::string ex(str, iter.base());
   15325                                     assert(ex == "*********************-0;0");
   15326                                     assert(ios.width() == 0);
   15327                                 }
   15328                                 ios.width(25);
   15329                                 internal(ios);
   15330                                 {
   15331                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15332                                     std::string ex(str, iter.base());
   15333                                     assert(ex == "-*********************0;0");
   15334                                     assert(ios.width() == 0);
   15335                                 }
   15336                             }
   15337                         }
   15338                     }
   15339                     showpos(ios);
   15340                     {
   15341                         noshowpoint(ios);
   15342                         {
   15343                             ios.imbue(lc);
   15344                             {
   15345                                 ios.width(0);
   15346                                 {
   15347                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15348                                     std::string ex(str, iter.base());
   15349                                     assert(ex == "-0.0");
   15350                                     assert(ios.width() == 0);
   15351                                 }
   15352                                 ios.width(25);
   15353                                 left(ios);
   15354                                 {
   15355                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15356                                     std::string ex(str, iter.base());
   15357                                     assert(ex == "-0.0*********************");
   15358                                     assert(ios.width() == 0);
   15359                                 }
   15360                                 ios.width(25);
   15361                                 right(ios);
   15362                                 {
   15363                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15364                                     std::string ex(str, iter.base());
   15365                                     assert(ex == "*********************-0.0");
   15366                                     assert(ios.width() == 0);
   15367                                 }
   15368                                 ios.width(25);
   15369                                 internal(ios);
   15370                                 {
   15371                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15372                                     std::string ex(str, iter.base());
   15373                                     assert(ex == "-*********************0.0");
   15374                                     assert(ios.width() == 0);
   15375                                 }
   15376                             }
   15377                             ios.imbue(lg);
   15378                             {
   15379                                 ios.width(0);
   15380                                 {
   15381                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15382                                     std::string ex(str, iter.base());
   15383                                     assert(ex == "-0;0");
   15384                                     assert(ios.width() == 0);
   15385                                 }
   15386                                 ios.width(25);
   15387                                 left(ios);
   15388                                 {
   15389                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15390                                     std::string ex(str, iter.base());
   15391                                     assert(ex == "-0;0*********************");
   15392                                     assert(ios.width() == 0);
   15393                                 }
   15394                                 ios.width(25);
   15395                                 right(ios);
   15396                                 {
   15397                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15398                                     std::string ex(str, iter.base());
   15399                                     assert(ex == "*********************-0;0");
   15400                                     assert(ios.width() == 0);
   15401                                 }
   15402                                 ios.width(25);
   15403                                 internal(ios);
   15404                                 {
   15405                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15406                                     std::string ex(str, iter.base());
   15407                                     assert(ex == "-*********************0;0");
   15408                                     assert(ios.width() == 0);
   15409                                 }
   15410                             }
   15411                         }
   15412                         showpoint(ios);
   15413                         {
   15414                             ios.imbue(lc);
   15415                             {
   15416                                 ios.width(0);
   15417                                 {
   15418                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15419                                     std::string ex(str, iter.base());
   15420                                     assert(ex == "-0.0");
   15421                                     assert(ios.width() == 0);
   15422                                 }
   15423                                 ios.width(25);
   15424                                 left(ios);
   15425                                 {
   15426                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15427                                     std::string ex(str, iter.base());
   15428                                     assert(ex == "-0.0*********************");
   15429                                     assert(ios.width() == 0);
   15430                                 }
   15431                                 ios.width(25);
   15432                                 right(ios);
   15433                                 {
   15434                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15435                                     std::string ex(str, iter.base());
   15436                                     assert(ex == "*********************-0.0");
   15437                                     assert(ios.width() == 0);
   15438                                 }
   15439                                 ios.width(25);
   15440                                 internal(ios);
   15441                                 {
   15442                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15443                                     std::string ex(str, iter.base());
   15444                                     assert(ex == "-*********************0.0");
   15445                                     assert(ios.width() == 0);
   15446                                 }
   15447                             }
   15448                             ios.imbue(lg);
   15449                             {
   15450                                 ios.width(0);
   15451                                 {
   15452                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15453                                     std::string ex(str, iter.base());
   15454                                     assert(ex == "-0;0");
   15455                                     assert(ios.width() == 0);
   15456                                 }
   15457                                 ios.width(25);
   15458                                 left(ios);
   15459                                 {
   15460                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15461                                     std::string ex(str, iter.base());
   15462                                     assert(ex == "-0;0*********************");
   15463                                     assert(ios.width() == 0);
   15464                                 }
   15465                                 ios.width(25);
   15466                                 right(ios);
   15467                                 {
   15468                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15469                                     std::string ex(str, iter.base());
   15470                                     assert(ex == "*********************-0;0");
   15471                                     assert(ios.width() == 0);
   15472                                 }
   15473                                 ios.width(25);
   15474                                 internal(ios);
   15475                                 {
   15476                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15477                                     std::string ex(str, iter.base());
   15478                                     assert(ex == "-*********************0;0");
   15479                                     assert(ios.width() == 0);
   15480                                 }
   15481                             }
   15482                         }
   15483                     }
   15484                 }
   15485             }
   15486             ios.precision(6);
   15487             {
   15488                 nouppercase(ios);
   15489                 {
   15490                     noshowpos(ios);
   15491                     {
   15492                         noshowpoint(ios);
   15493                         {
   15494                             ios.imbue(lc);
   15495                             {
   15496                                 ios.width(0);
   15497                                 {
   15498                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15499                                     std::string ex(str, iter.base());
   15500                                     assert(ex == "-0.000000");
   15501                                     assert(ios.width() == 0);
   15502                                 }
   15503                                 ios.width(25);
   15504                                 left(ios);
   15505                                 {
   15506                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15507                                     std::string ex(str, iter.base());
   15508                                     assert(ex == "-0.000000****************");
   15509                                     assert(ios.width() == 0);
   15510                                 }
   15511                                 ios.width(25);
   15512                                 right(ios);
   15513                                 {
   15514                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15515                                     std::string ex(str, iter.base());
   15516                                     assert(ex == "****************-0.000000");
   15517                                     assert(ios.width() == 0);
   15518                                 }
   15519                                 ios.width(25);
   15520                                 internal(ios);
   15521                                 {
   15522                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15523                                     std::string ex(str, iter.base());
   15524                                     assert(ex == "-****************0.000000");
   15525                                     assert(ios.width() == 0);
   15526                                 }
   15527                             }
   15528                             ios.imbue(lg);
   15529                             {
   15530                                 ios.width(0);
   15531                                 {
   15532                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15533                                     std::string ex(str, iter.base());
   15534                                     assert(ex == "-0;000000");
   15535                                     assert(ios.width() == 0);
   15536                                 }
   15537                                 ios.width(25);
   15538                                 left(ios);
   15539                                 {
   15540                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15541                                     std::string ex(str, iter.base());
   15542                                     assert(ex == "-0;000000****************");
   15543                                     assert(ios.width() == 0);
   15544                                 }
   15545                                 ios.width(25);
   15546                                 right(ios);
   15547                                 {
   15548                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15549                                     std::string ex(str, iter.base());
   15550                                     assert(ex == "****************-0;000000");
   15551                                     assert(ios.width() == 0);
   15552                                 }
   15553                                 ios.width(25);
   15554                                 internal(ios);
   15555                                 {
   15556                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15557                                     std::string ex(str, iter.base());
   15558                                     assert(ex == "-****************0;000000");
   15559                                     assert(ios.width() == 0);
   15560                                 }
   15561                             }
   15562                         }
   15563                         showpoint(ios);
   15564                         {
   15565                             ios.imbue(lc);
   15566                             {
   15567                                 ios.width(0);
   15568                                 {
   15569                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15570                                     std::string ex(str, iter.base());
   15571                                     assert(ex == "-0.000000");
   15572                                     assert(ios.width() == 0);
   15573                                 }
   15574                                 ios.width(25);
   15575                                 left(ios);
   15576                                 {
   15577                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15578                                     std::string ex(str, iter.base());
   15579                                     assert(ex == "-0.000000****************");
   15580                                     assert(ios.width() == 0);
   15581                                 }
   15582                                 ios.width(25);
   15583                                 right(ios);
   15584                                 {
   15585                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15586                                     std::string ex(str, iter.base());
   15587                                     assert(ex == "****************-0.000000");
   15588                                     assert(ios.width() == 0);
   15589                                 }
   15590                                 ios.width(25);
   15591                                 internal(ios);
   15592                                 {
   15593                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15594                                     std::string ex(str, iter.base());
   15595                                     assert(ex == "-****************0.000000");
   15596                                     assert(ios.width() == 0);
   15597                                 }
   15598                             }
   15599                             ios.imbue(lg);
   15600                             {
   15601                                 ios.width(0);
   15602                                 {
   15603                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15604                                     std::string ex(str, iter.base());
   15605                                     assert(ex == "-0;000000");
   15606                                     assert(ios.width() == 0);
   15607                                 }
   15608                                 ios.width(25);
   15609                                 left(ios);
   15610                                 {
   15611                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15612                                     std::string ex(str, iter.base());
   15613                                     assert(ex == "-0;000000****************");
   15614                                     assert(ios.width() == 0);
   15615                                 }
   15616                                 ios.width(25);
   15617                                 right(ios);
   15618                                 {
   15619                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15620                                     std::string ex(str, iter.base());
   15621                                     assert(ex == "****************-0;000000");
   15622                                     assert(ios.width() == 0);
   15623                                 }
   15624                                 ios.width(25);
   15625                                 internal(ios);
   15626                                 {
   15627                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15628                                     std::string ex(str, iter.base());
   15629                                     assert(ex == "-****************0;000000");
   15630                                     assert(ios.width() == 0);
   15631                                 }
   15632                             }
   15633                         }
   15634                     }
   15635                     showpos(ios);
   15636                     {
   15637                         noshowpoint(ios);
   15638                         {
   15639                             ios.imbue(lc);
   15640                             {
   15641                                 ios.width(0);
   15642                                 {
   15643                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15644                                     std::string ex(str, iter.base());
   15645                                     assert(ex == "-0.000000");
   15646                                     assert(ios.width() == 0);
   15647                                 }
   15648                                 ios.width(25);
   15649                                 left(ios);
   15650                                 {
   15651                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15652                                     std::string ex(str, iter.base());
   15653                                     assert(ex == "-0.000000****************");
   15654                                     assert(ios.width() == 0);
   15655                                 }
   15656                                 ios.width(25);
   15657                                 right(ios);
   15658                                 {
   15659                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15660                                     std::string ex(str, iter.base());
   15661                                     assert(ex == "****************-0.000000");
   15662                                     assert(ios.width() == 0);
   15663                                 }
   15664                                 ios.width(25);
   15665                                 internal(ios);
   15666                                 {
   15667                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15668                                     std::string ex(str, iter.base());
   15669                                     assert(ex == "-****************0.000000");
   15670                                     assert(ios.width() == 0);
   15671                                 }
   15672                             }
   15673                             ios.imbue(lg);
   15674                             {
   15675                                 ios.width(0);
   15676                                 {
   15677                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15678                                     std::string ex(str, iter.base());
   15679                                     assert(ex == "-0;000000");
   15680                                     assert(ios.width() == 0);
   15681                                 }
   15682                                 ios.width(25);
   15683                                 left(ios);
   15684                                 {
   15685                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15686                                     std::string ex(str, iter.base());
   15687                                     assert(ex == "-0;000000****************");
   15688                                     assert(ios.width() == 0);
   15689                                 }
   15690                                 ios.width(25);
   15691                                 right(ios);
   15692                                 {
   15693                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15694                                     std::string ex(str, iter.base());
   15695                                     assert(ex == "****************-0;000000");
   15696                                     assert(ios.width() == 0);
   15697                                 }
   15698                                 ios.width(25);
   15699                                 internal(ios);
   15700                                 {
   15701                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15702                                     std::string ex(str, iter.base());
   15703                                     assert(ex == "-****************0;000000");
   15704                                     assert(ios.width() == 0);
   15705                                 }
   15706                             }
   15707                         }
   15708                         showpoint(ios);
   15709                         {
   15710                             ios.imbue(lc);
   15711                             {
   15712                                 ios.width(0);
   15713                                 {
   15714                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15715                                     std::string ex(str, iter.base());
   15716                                     assert(ex == "-0.000000");
   15717                                     assert(ios.width() == 0);
   15718                                 }
   15719                                 ios.width(25);
   15720                                 left(ios);
   15721                                 {
   15722                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15723                                     std::string ex(str, iter.base());
   15724                                     assert(ex == "-0.000000****************");
   15725                                     assert(ios.width() == 0);
   15726                                 }
   15727                                 ios.width(25);
   15728                                 right(ios);
   15729                                 {
   15730                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15731                                     std::string ex(str, iter.base());
   15732                                     assert(ex == "****************-0.000000");
   15733                                     assert(ios.width() == 0);
   15734                                 }
   15735                                 ios.width(25);
   15736                                 internal(ios);
   15737                                 {
   15738                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15739                                     std::string ex(str, iter.base());
   15740                                     assert(ex == "-****************0.000000");
   15741                                     assert(ios.width() == 0);
   15742                                 }
   15743                             }
   15744                             ios.imbue(lg);
   15745                             {
   15746                                 ios.width(0);
   15747                                 {
   15748                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15749                                     std::string ex(str, iter.base());
   15750                                     assert(ex == "-0;000000");
   15751                                     assert(ios.width() == 0);
   15752                                 }
   15753                                 ios.width(25);
   15754                                 left(ios);
   15755                                 {
   15756                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15757                                     std::string ex(str, iter.base());
   15758                                     assert(ex == "-0;000000****************");
   15759                                     assert(ios.width() == 0);
   15760                                 }
   15761                                 ios.width(25);
   15762                                 right(ios);
   15763                                 {
   15764                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15765                                     std::string ex(str, iter.base());
   15766                                     assert(ex == "****************-0;000000");
   15767                                     assert(ios.width() == 0);
   15768                                 }
   15769                                 ios.width(25);
   15770                                 internal(ios);
   15771                                 {
   15772                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15773                                     std::string ex(str, iter.base());
   15774                                     assert(ex == "-****************0;000000");
   15775                                     assert(ios.width() == 0);
   15776                                 }
   15777                             }
   15778                         }
   15779                     }
   15780                 }
   15781                 uppercase(ios);
   15782                 {
   15783                     noshowpos(ios);
   15784                     {
   15785                         noshowpoint(ios);
   15786                         {
   15787                             ios.imbue(lc);
   15788                             {
   15789                                 ios.width(0);
   15790                                 {
   15791                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15792                                     std::string ex(str, iter.base());
   15793                                     assert(ex == "-0.000000");
   15794                                     assert(ios.width() == 0);
   15795                                 }
   15796                                 ios.width(25);
   15797                                 left(ios);
   15798                                 {
   15799                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15800                                     std::string ex(str, iter.base());
   15801                                     assert(ex == "-0.000000****************");
   15802                                     assert(ios.width() == 0);
   15803                                 }
   15804                                 ios.width(25);
   15805                                 right(ios);
   15806                                 {
   15807                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15808                                     std::string ex(str, iter.base());
   15809                                     assert(ex == "****************-0.000000");
   15810                                     assert(ios.width() == 0);
   15811                                 }
   15812                                 ios.width(25);
   15813                                 internal(ios);
   15814                                 {
   15815                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15816                                     std::string ex(str, iter.base());
   15817                                     assert(ex == "-****************0.000000");
   15818                                     assert(ios.width() == 0);
   15819                                 }
   15820                             }
   15821                             ios.imbue(lg);
   15822                             {
   15823                                 ios.width(0);
   15824                                 {
   15825                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15826                                     std::string ex(str, iter.base());
   15827                                     assert(ex == "-0;000000");
   15828                                     assert(ios.width() == 0);
   15829                                 }
   15830                                 ios.width(25);
   15831                                 left(ios);
   15832                                 {
   15833                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15834                                     std::string ex(str, iter.base());
   15835                                     assert(ex == "-0;000000****************");
   15836                                     assert(ios.width() == 0);
   15837                                 }
   15838                                 ios.width(25);
   15839                                 right(ios);
   15840                                 {
   15841                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15842                                     std::string ex(str, iter.base());
   15843                                     assert(ex == "****************-0;000000");
   15844                                     assert(ios.width() == 0);
   15845                                 }
   15846                                 ios.width(25);
   15847                                 internal(ios);
   15848                                 {
   15849                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15850                                     std::string ex(str, iter.base());
   15851                                     assert(ex == "-****************0;000000");
   15852                                     assert(ios.width() == 0);
   15853                                 }
   15854                             }
   15855                         }
   15856                         showpoint(ios);
   15857                         {
   15858                             ios.imbue(lc);
   15859                             {
   15860                                 ios.width(0);
   15861                                 {
   15862                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15863                                     std::string ex(str, iter.base());
   15864                                     assert(ex == "-0.000000");
   15865                                     assert(ios.width() == 0);
   15866                                 }
   15867                                 ios.width(25);
   15868                                 left(ios);
   15869                                 {
   15870                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15871                                     std::string ex(str, iter.base());
   15872                                     assert(ex == "-0.000000****************");
   15873                                     assert(ios.width() == 0);
   15874                                 }
   15875                                 ios.width(25);
   15876                                 right(ios);
   15877                                 {
   15878                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15879                                     std::string ex(str, iter.base());
   15880                                     assert(ex == "****************-0.000000");
   15881                                     assert(ios.width() == 0);
   15882                                 }
   15883                                 ios.width(25);
   15884                                 internal(ios);
   15885                                 {
   15886                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15887                                     std::string ex(str, iter.base());
   15888                                     assert(ex == "-****************0.000000");
   15889                                     assert(ios.width() == 0);
   15890                                 }
   15891                             }
   15892                             ios.imbue(lg);
   15893                             {
   15894                                 ios.width(0);
   15895                                 {
   15896                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15897                                     std::string ex(str, iter.base());
   15898                                     assert(ex == "-0;000000");
   15899                                     assert(ios.width() == 0);
   15900                                 }
   15901                                 ios.width(25);
   15902                                 left(ios);
   15903                                 {
   15904                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15905                                     std::string ex(str, iter.base());
   15906                                     assert(ex == "-0;000000****************");
   15907                                     assert(ios.width() == 0);
   15908                                 }
   15909                                 ios.width(25);
   15910                                 right(ios);
   15911                                 {
   15912                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15913                                     std::string ex(str, iter.base());
   15914                                     assert(ex == "****************-0;000000");
   15915                                     assert(ios.width() == 0);
   15916                                 }
   15917                                 ios.width(25);
   15918                                 internal(ios);
   15919                                 {
   15920                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15921                                     std::string ex(str, iter.base());
   15922                                     assert(ex == "-****************0;000000");
   15923                                     assert(ios.width() == 0);
   15924                                 }
   15925                             }
   15926                         }
   15927                     }
   15928                     showpos(ios);
   15929                     {
   15930                         noshowpoint(ios);
   15931                         {
   15932                             ios.imbue(lc);
   15933                             {
   15934                                 ios.width(0);
   15935                                 {
   15936                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15937                                     std::string ex(str, iter.base());
   15938                                     assert(ex == "-0.000000");
   15939                                     assert(ios.width() == 0);
   15940                                 }
   15941                                 ios.width(25);
   15942                                 left(ios);
   15943                                 {
   15944                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15945                                     std::string ex(str, iter.base());
   15946                                     assert(ex == "-0.000000****************");
   15947                                     assert(ios.width() == 0);
   15948                                 }
   15949                                 ios.width(25);
   15950                                 right(ios);
   15951                                 {
   15952                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15953                                     std::string ex(str, iter.base());
   15954                                     assert(ex == "****************-0.000000");
   15955                                     assert(ios.width() == 0);
   15956                                 }
   15957                                 ios.width(25);
   15958                                 internal(ios);
   15959                                 {
   15960                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15961                                     std::string ex(str, iter.base());
   15962                                     assert(ex == "-****************0.000000");
   15963                                     assert(ios.width() == 0);
   15964                                 }
   15965                             }
   15966                             ios.imbue(lg);
   15967                             {
   15968                                 ios.width(0);
   15969                                 {
   15970                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15971                                     std::string ex(str, iter.base());
   15972                                     assert(ex == "-0;000000");
   15973                                     assert(ios.width() == 0);
   15974                                 }
   15975                                 ios.width(25);
   15976                                 left(ios);
   15977                                 {
   15978                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15979                                     std::string ex(str, iter.base());
   15980                                     assert(ex == "-0;000000****************");
   15981                                     assert(ios.width() == 0);
   15982                                 }
   15983                                 ios.width(25);
   15984                                 right(ios);
   15985                                 {
   15986                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15987                                     std::string ex(str, iter.base());
   15988                                     assert(ex == "****************-0;000000");
   15989                                     assert(ios.width() == 0);
   15990                                 }
   15991                                 ios.width(25);
   15992                                 internal(ios);
   15993                                 {
   15994                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15995                                     std::string ex(str, iter.base());
   15996                                     assert(ex == "-****************0;000000");
   15997                                     assert(ios.width() == 0);
   15998                                 }
   15999                             }
   16000                         }
   16001                         showpoint(ios);
   16002                         {
   16003                             ios.imbue(lc);
   16004                             {
   16005                                 ios.width(0);
   16006                                 {
   16007                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16008                                     std::string ex(str, iter.base());
   16009                                     assert(ex == "-0.000000");
   16010                                     assert(ios.width() == 0);
   16011                                 }
   16012                                 ios.width(25);
   16013                                 left(ios);
   16014                                 {
   16015                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16016                                     std::string ex(str, iter.base());
   16017                                     assert(ex == "-0.000000****************");
   16018                                     assert(ios.width() == 0);
   16019                                 }
   16020                                 ios.width(25);
   16021                                 right(ios);
   16022                                 {
   16023                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16024                                     std::string ex(str, iter.base());
   16025                                     assert(ex == "****************-0.000000");
   16026                                     assert(ios.width() == 0);
   16027                                 }
   16028                                 ios.width(25);
   16029                                 internal(ios);
   16030                                 {
   16031                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16032                                     std::string ex(str, iter.base());
   16033                                     assert(ex == "-****************0.000000");
   16034                                     assert(ios.width() == 0);
   16035                                 }
   16036                             }
   16037                             ios.imbue(lg);
   16038                             {
   16039                                 ios.width(0);
   16040                                 {
   16041                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16042                                     std::string ex(str, iter.base());
   16043                                     assert(ex == "-0;000000");
   16044                                     assert(ios.width() == 0);
   16045                                 }
   16046                                 ios.width(25);
   16047                                 left(ios);
   16048                                 {
   16049                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16050                                     std::string ex(str, iter.base());
   16051                                     assert(ex == "-0;000000****************");
   16052                                     assert(ios.width() == 0);
   16053                                 }
   16054                                 ios.width(25);
   16055                                 right(ios);
   16056                                 {
   16057                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16058                                     std::string ex(str, iter.base());
   16059                                     assert(ex == "****************-0;000000");
   16060                                     assert(ios.width() == 0);
   16061                                 }
   16062                                 ios.width(25);
   16063                                 internal(ios);
   16064                                 {
   16065                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16066                                     std::string ex(str, iter.base());
   16067                                     assert(ex == "-****************0;000000");
   16068                                     assert(ios.width() == 0);
   16069                                 }
   16070                             }
   16071                         }
   16072                     }
   16073                 }
   16074             }
   16075             ios.precision(16);
   16076             {
   16077                 nouppercase(ios);
   16078                 {
   16079                     noshowpos(ios);
   16080                     {
   16081                         noshowpoint(ios);
   16082                         {
   16083                             ios.imbue(lc);
   16084                             {
   16085                                 ios.width(0);
   16086                                 {
   16087                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16088                                     std::string ex(str, iter.base());
   16089                                     assert(ex == "-0.0000000000000000");
   16090                                     assert(ios.width() == 0);
   16091                                 }
   16092                                 ios.width(25);
   16093                                 left(ios);
   16094                                 {
   16095                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16096                                     std::string ex(str, iter.base());
   16097                                     assert(ex == "-0.0000000000000000******");
   16098                                     assert(ios.width() == 0);
   16099                                 }
   16100                                 ios.width(25);
   16101                                 right(ios);
   16102                                 {
   16103                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16104                                     std::string ex(str, iter.base());
   16105                                     assert(ex == "******-0.0000000000000000");
   16106                                     assert(ios.width() == 0);
   16107                                 }
   16108                                 ios.width(25);
   16109                                 internal(ios);
   16110                                 {
   16111                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16112                                     std::string ex(str, iter.base());
   16113                                     assert(ex == "-******0.0000000000000000");
   16114                                     assert(ios.width() == 0);
   16115                                 }
   16116                             }
   16117                             ios.imbue(lg);
   16118                             {
   16119                                 ios.width(0);
   16120                                 {
   16121                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16122                                     std::string ex(str, iter.base());
   16123                                     assert(ex == "-0;0000000000000000");
   16124                                     assert(ios.width() == 0);
   16125                                 }
   16126                                 ios.width(25);
   16127                                 left(ios);
   16128                                 {
   16129                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16130                                     std::string ex(str, iter.base());
   16131                                     assert(ex == "-0;0000000000000000******");
   16132                                     assert(ios.width() == 0);
   16133                                 }
   16134                                 ios.width(25);
   16135                                 right(ios);
   16136                                 {
   16137                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16138                                     std::string ex(str, iter.base());
   16139                                     assert(ex == "******-0;0000000000000000");
   16140                                     assert(ios.width() == 0);
   16141                                 }
   16142                                 ios.width(25);
   16143                                 internal(ios);
   16144                                 {
   16145                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16146                                     std::string ex(str, iter.base());
   16147                                     assert(ex == "-******0;0000000000000000");
   16148                                     assert(ios.width() == 0);
   16149                                 }
   16150                             }
   16151                         }
   16152                         showpoint(ios);
   16153                         {
   16154                             ios.imbue(lc);
   16155                             {
   16156                                 ios.width(0);
   16157                                 {
   16158                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16159                                     std::string ex(str, iter.base());
   16160                                     assert(ex == "-0.0000000000000000");
   16161                                     assert(ios.width() == 0);
   16162                                 }
   16163                                 ios.width(25);
   16164                                 left(ios);
   16165                                 {
   16166                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16167                                     std::string ex(str, iter.base());
   16168                                     assert(ex == "-0.0000000000000000******");
   16169                                     assert(ios.width() == 0);
   16170                                 }
   16171                                 ios.width(25);
   16172                                 right(ios);
   16173                                 {
   16174                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16175                                     std::string ex(str, iter.base());
   16176                                     assert(ex == "******-0.0000000000000000");
   16177                                     assert(ios.width() == 0);
   16178                                 }
   16179                                 ios.width(25);
   16180                                 internal(ios);
   16181                                 {
   16182                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16183                                     std::string ex(str, iter.base());
   16184                                     assert(ex == "-******0.0000000000000000");
   16185                                     assert(ios.width() == 0);
   16186                                 }
   16187                             }
   16188                             ios.imbue(lg);
   16189                             {
   16190                                 ios.width(0);
   16191                                 {
   16192                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16193                                     std::string ex(str, iter.base());
   16194                                     assert(ex == "-0;0000000000000000");
   16195                                     assert(ios.width() == 0);
   16196                                 }
   16197                                 ios.width(25);
   16198                                 left(ios);
   16199                                 {
   16200                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16201                                     std::string ex(str, iter.base());
   16202                                     assert(ex == "-0;0000000000000000******");
   16203                                     assert(ios.width() == 0);
   16204                                 }
   16205                                 ios.width(25);
   16206                                 right(ios);
   16207                                 {
   16208                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16209                                     std::string ex(str, iter.base());
   16210                                     assert(ex == "******-0;0000000000000000");
   16211                                     assert(ios.width() == 0);
   16212                                 }
   16213                                 ios.width(25);
   16214                                 internal(ios);
   16215                                 {
   16216                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16217                                     std::string ex(str, iter.base());
   16218                                     assert(ex == "-******0;0000000000000000");
   16219                                     assert(ios.width() == 0);
   16220                                 }
   16221                             }
   16222                         }
   16223                     }
   16224                     showpos(ios);
   16225                     {
   16226                         noshowpoint(ios);
   16227                         {
   16228                             ios.imbue(lc);
   16229                             {
   16230                                 ios.width(0);
   16231                                 {
   16232                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16233                                     std::string ex(str, iter.base());
   16234                                     assert(ex == "-0.0000000000000000");
   16235                                     assert(ios.width() == 0);
   16236                                 }
   16237                                 ios.width(25);
   16238                                 left(ios);
   16239                                 {
   16240                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16241                                     std::string ex(str, iter.base());
   16242                                     assert(ex == "-0.0000000000000000******");
   16243                                     assert(ios.width() == 0);
   16244                                 }
   16245                                 ios.width(25);
   16246                                 right(ios);
   16247                                 {
   16248                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16249                                     std::string ex(str, iter.base());
   16250                                     assert(ex == "******-0.0000000000000000");
   16251                                     assert(ios.width() == 0);
   16252                                 }
   16253                                 ios.width(25);
   16254                                 internal(ios);
   16255                                 {
   16256                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16257                                     std::string ex(str, iter.base());
   16258                                     assert(ex == "-******0.0000000000000000");
   16259                                     assert(ios.width() == 0);
   16260                                 }
   16261                             }
   16262                             ios.imbue(lg);
   16263                             {
   16264                                 ios.width(0);
   16265                                 {
   16266                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16267                                     std::string ex(str, iter.base());
   16268                                     assert(ex == "-0;0000000000000000");
   16269                                     assert(ios.width() == 0);
   16270                                 }
   16271                                 ios.width(25);
   16272                                 left(ios);
   16273                                 {
   16274                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16275                                     std::string ex(str, iter.base());
   16276                                     assert(ex == "-0;0000000000000000******");
   16277                                     assert(ios.width() == 0);
   16278                                 }
   16279                                 ios.width(25);
   16280                                 right(ios);
   16281                                 {
   16282                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16283                                     std::string ex(str, iter.base());
   16284                                     assert(ex == "******-0;0000000000000000");
   16285                                     assert(ios.width() == 0);
   16286                                 }
   16287                                 ios.width(25);
   16288                                 internal(ios);
   16289                                 {
   16290                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16291                                     std::string ex(str, iter.base());
   16292                                     assert(ex == "-******0;0000000000000000");
   16293                                     assert(ios.width() == 0);
   16294                                 }
   16295                             }
   16296                         }
   16297                         showpoint(ios);
   16298                         {
   16299                             ios.imbue(lc);
   16300                             {
   16301                                 ios.width(0);
   16302                                 {
   16303                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16304                                     std::string ex(str, iter.base());
   16305                                     assert(ex == "-0.0000000000000000");
   16306                                     assert(ios.width() == 0);
   16307                                 }
   16308                                 ios.width(25);
   16309                                 left(ios);
   16310                                 {
   16311                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16312                                     std::string ex(str, iter.base());
   16313                                     assert(ex == "-0.0000000000000000******");
   16314                                     assert(ios.width() == 0);
   16315                                 }
   16316                                 ios.width(25);
   16317                                 right(ios);
   16318                                 {
   16319                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16320                                     std::string ex(str, iter.base());
   16321                                     assert(ex == "******-0.0000000000000000");
   16322                                     assert(ios.width() == 0);
   16323                                 }
   16324                                 ios.width(25);
   16325                                 internal(ios);
   16326                                 {
   16327                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16328                                     std::string ex(str, iter.base());
   16329                                     assert(ex == "-******0.0000000000000000");
   16330                                     assert(ios.width() == 0);
   16331                                 }
   16332                             }
   16333                             ios.imbue(lg);
   16334                             {
   16335                                 ios.width(0);
   16336                                 {
   16337                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16338                                     std::string ex(str, iter.base());
   16339                                     assert(ex == "-0;0000000000000000");
   16340                                     assert(ios.width() == 0);
   16341                                 }
   16342                                 ios.width(25);
   16343                                 left(ios);
   16344                                 {
   16345                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16346                                     std::string ex(str, iter.base());
   16347                                     assert(ex == "-0;0000000000000000******");
   16348                                     assert(ios.width() == 0);
   16349                                 }
   16350                                 ios.width(25);
   16351                                 right(ios);
   16352                                 {
   16353                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16354                                     std::string ex(str, iter.base());
   16355                                     assert(ex == "******-0;0000000000000000");
   16356                                     assert(ios.width() == 0);
   16357                                 }
   16358                                 ios.width(25);
   16359                                 internal(ios);
   16360                                 {
   16361                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16362                                     std::string ex(str, iter.base());
   16363                                     assert(ex == "-******0;0000000000000000");
   16364                                     assert(ios.width() == 0);
   16365                                 }
   16366                             }
   16367                         }
   16368                     }
   16369                 }
   16370                 uppercase(ios);
   16371                 {
   16372                     noshowpos(ios);
   16373                     {
   16374                         noshowpoint(ios);
   16375                         {
   16376                             ios.imbue(lc);
   16377                             {
   16378                                 ios.width(0);
   16379                                 {
   16380                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16381                                     std::string ex(str, iter.base());
   16382                                     assert(ex == "-0.0000000000000000");
   16383                                     assert(ios.width() == 0);
   16384                                 }
   16385                                 ios.width(25);
   16386                                 left(ios);
   16387                                 {
   16388                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16389                                     std::string ex(str, iter.base());
   16390                                     assert(ex == "-0.0000000000000000******");
   16391                                     assert(ios.width() == 0);
   16392                                 }
   16393                                 ios.width(25);
   16394                                 right(ios);
   16395                                 {
   16396                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16397                                     std::string ex(str, iter.base());
   16398                                     assert(ex == "******-0.0000000000000000");
   16399                                     assert(ios.width() == 0);
   16400                                 }
   16401                                 ios.width(25);
   16402                                 internal(ios);
   16403                                 {
   16404                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16405                                     std::string ex(str, iter.base());
   16406                                     assert(ex == "-******0.0000000000000000");
   16407                                     assert(ios.width() == 0);
   16408                                 }
   16409                             }
   16410                             ios.imbue(lg);
   16411                             {
   16412                                 ios.width(0);
   16413                                 {
   16414                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16415                                     std::string ex(str, iter.base());
   16416                                     assert(ex == "-0;0000000000000000");
   16417                                     assert(ios.width() == 0);
   16418                                 }
   16419                                 ios.width(25);
   16420                                 left(ios);
   16421                                 {
   16422                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16423                                     std::string ex(str, iter.base());
   16424                                     assert(ex == "-0;0000000000000000******");
   16425                                     assert(ios.width() == 0);
   16426                                 }
   16427                                 ios.width(25);
   16428                                 right(ios);
   16429                                 {
   16430                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16431                                     std::string ex(str, iter.base());
   16432                                     assert(ex == "******-0;0000000000000000");
   16433                                     assert(ios.width() == 0);
   16434                                 }
   16435                                 ios.width(25);
   16436                                 internal(ios);
   16437                                 {
   16438                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16439                                     std::string ex(str, iter.base());
   16440                                     assert(ex == "-******0;0000000000000000");
   16441                                     assert(ios.width() == 0);
   16442                                 }
   16443                             }
   16444                         }
   16445                         showpoint(ios);
   16446                         {
   16447                             ios.imbue(lc);
   16448                             {
   16449                                 ios.width(0);
   16450                                 {
   16451                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16452                                     std::string ex(str, iter.base());
   16453                                     assert(ex == "-0.0000000000000000");
   16454                                     assert(ios.width() == 0);
   16455                                 }
   16456                                 ios.width(25);
   16457                                 left(ios);
   16458                                 {
   16459                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16460                                     std::string ex(str, iter.base());
   16461                                     assert(ex == "-0.0000000000000000******");
   16462                                     assert(ios.width() == 0);
   16463                                 }
   16464                                 ios.width(25);
   16465                                 right(ios);
   16466                                 {
   16467                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16468                                     std::string ex(str, iter.base());
   16469                                     assert(ex == "******-0.0000000000000000");
   16470                                     assert(ios.width() == 0);
   16471                                 }
   16472                                 ios.width(25);
   16473                                 internal(ios);
   16474                                 {
   16475                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16476                                     std::string ex(str, iter.base());
   16477                                     assert(ex == "-******0.0000000000000000");
   16478                                     assert(ios.width() == 0);
   16479                                 }
   16480                             }
   16481                             ios.imbue(lg);
   16482                             {
   16483                                 ios.width(0);
   16484                                 {
   16485                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16486                                     std::string ex(str, iter.base());
   16487                                     assert(ex == "-0;0000000000000000");
   16488                                     assert(ios.width() == 0);
   16489                                 }
   16490                                 ios.width(25);
   16491                                 left(ios);
   16492                                 {
   16493                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16494                                     std::string ex(str, iter.base());
   16495                                     assert(ex == "-0;0000000000000000******");
   16496                                     assert(ios.width() == 0);
   16497                                 }
   16498                                 ios.width(25);
   16499                                 right(ios);
   16500                                 {
   16501                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16502                                     std::string ex(str, iter.base());
   16503                                     assert(ex == "******-0;0000000000000000");
   16504                                     assert(ios.width() == 0);
   16505                                 }
   16506                                 ios.width(25);
   16507                                 internal(ios);
   16508                                 {
   16509                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16510                                     std::string ex(str, iter.base());
   16511                                     assert(ex == "-******0;0000000000000000");
   16512                                     assert(ios.width() == 0);
   16513                                 }
   16514                             }
   16515                         }
   16516                     }
   16517                     showpos(ios);
   16518                     {
   16519                         noshowpoint(ios);
   16520                         {
   16521                             ios.imbue(lc);
   16522                             {
   16523                                 ios.width(0);
   16524                                 {
   16525                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16526                                     std::string ex(str, iter.base());
   16527                                     assert(ex == "-0.0000000000000000");
   16528                                     assert(ios.width() == 0);
   16529                                 }
   16530                                 ios.width(25);
   16531                                 left(ios);
   16532                                 {
   16533                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16534                                     std::string ex(str, iter.base());
   16535                                     assert(ex == "-0.0000000000000000******");
   16536                                     assert(ios.width() == 0);
   16537                                 }
   16538                                 ios.width(25);
   16539                                 right(ios);
   16540                                 {
   16541                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16542                                     std::string ex(str, iter.base());
   16543                                     assert(ex == "******-0.0000000000000000");
   16544                                     assert(ios.width() == 0);
   16545                                 }
   16546                                 ios.width(25);
   16547                                 internal(ios);
   16548                                 {
   16549                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16550                                     std::string ex(str, iter.base());
   16551                                     assert(ex == "-******0.0000000000000000");
   16552                                     assert(ios.width() == 0);
   16553                                 }
   16554                             }
   16555                             ios.imbue(lg);
   16556                             {
   16557                                 ios.width(0);
   16558                                 {
   16559                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16560                                     std::string ex(str, iter.base());
   16561                                     assert(ex == "-0;0000000000000000");
   16562                                     assert(ios.width() == 0);
   16563                                 }
   16564                                 ios.width(25);
   16565                                 left(ios);
   16566                                 {
   16567                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16568                                     std::string ex(str, iter.base());
   16569                                     assert(ex == "-0;0000000000000000******");
   16570                                     assert(ios.width() == 0);
   16571                                 }
   16572                                 ios.width(25);
   16573                                 right(ios);
   16574                                 {
   16575                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16576                                     std::string ex(str, iter.base());
   16577                                     assert(ex == "******-0;0000000000000000");
   16578                                     assert(ios.width() == 0);
   16579                                 }
   16580                                 ios.width(25);
   16581                                 internal(ios);
   16582                                 {
   16583                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16584                                     std::string ex(str, iter.base());
   16585                                     assert(ex == "-******0;0000000000000000");
   16586                                     assert(ios.width() == 0);
   16587                                 }
   16588                             }
   16589                         }
   16590                         showpoint(ios);
   16591                         {
   16592                             ios.imbue(lc);
   16593                             {
   16594                                 ios.width(0);
   16595                                 {
   16596                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16597                                     std::string ex(str, iter.base());
   16598                                     assert(ex == "-0.0000000000000000");
   16599                                     assert(ios.width() == 0);
   16600                                 }
   16601                                 ios.width(25);
   16602                                 left(ios);
   16603                                 {
   16604                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16605                                     std::string ex(str, iter.base());
   16606                                     assert(ex == "-0.0000000000000000******");
   16607                                     assert(ios.width() == 0);
   16608                                 }
   16609                                 ios.width(25);
   16610                                 right(ios);
   16611                                 {
   16612                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16613                                     std::string ex(str, iter.base());
   16614                                     assert(ex == "******-0.0000000000000000");
   16615                                     assert(ios.width() == 0);
   16616                                 }
   16617                                 ios.width(25);
   16618                                 internal(ios);
   16619                                 {
   16620                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16621                                     std::string ex(str, iter.base());
   16622                                     assert(ex == "-******0.0000000000000000");
   16623                                     assert(ios.width() == 0);
   16624                                 }
   16625                             }
   16626                             ios.imbue(lg);
   16627                             {
   16628                                 ios.width(0);
   16629                                 {
   16630                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16631                                     std::string ex(str, iter.base());
   16632                                     assert(ex == "-0;0000000000000000");
   16633                                     assert(ios.width() == 0);
   16634                                 }
   16635                                 ios.width(25);
   16636                                 left(ios);
   16637                                 {
   16638                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16639                                     std::string ex(str, iter.base());
   16640                                     assert(ex == "-0;0000000000000000******");
   16641                                     assert(ios.width() == 0);
   16642                                 }
   16643                                 ios.width(25);
   16644                                 right(ios);
   16645                                 {
   16646                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16647                                     std::string ex(str, iter.base());
   16648                                     assert(ex == "******-0;0000000000000000");
   16649                                     assert(ios.width() == 0);
   16650                                 }
   16651                                 ios.width(25);
   16652                                 internal(ios);
   16653                                 {
   16654                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16655                                     std::string ex(str, iter.base());
   16656                                     assert(ex == "-******0;0000000000000000");
   16657                                     assert(ios.width() == 0);
   16658                                 }
   16659                             }
   16660                         }
   16661                     }
   16662                 }
   16663             }
   16664             ios.precision(60);
   16665             {
   16666                 nouppercase(ios);
   16667                 {
   16668                     noshowpos(ios);
   16669                     {
   16670                         noshowpoint(ios);
   16671                         {
   16672                             ios.imbue(lc);
   16673                             {
   16674                                 ios.width(0);
   16675                                 {
   16676                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16677                                     std::string ex(str, iter.base());
   16678                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16679                                     assert(ios.width() == 0);
   16680                                 }
   16681                                 ios.width(25);
   16682                                 left(ios);
   16683                                 {
   16684                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16685                                     std::string ex(str, iter.base());
   16686                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16687                                     assert(ios.width() == 0);
   16688                                 }
   16689                                 ios.width(25);
   16690                                 right(ios);
   16691                                 {
   16692                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16693                                     std::string ex(str, iter.base());
   16694                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16695                                     assert(ios.width() == 0);
   16696                                 }
   16697                                 ios.width(25);
   16698                                 internal(ios);
   16699                                 {
   16700                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16701                                     std::string ex(str, iter.base());
   16702                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16703                                     assert(ios.width() == 0);
   16704                                 }
   16705                             }
   16706                             ios.imbue(lg);
   16707                             {
   16708                                 ios.width(0);
   16709                                 {
   16710                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16711                                     std::string ex(str, iter.base());
   16712                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16713                                     assert(ios.width() == 0);
   16714                                 }
   16715                                 ios.width(25);
   16716                                 left(ios);
   16717                                 {
   16718                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16719                                     std::string ex(str, iter.base());
   16720                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16721                                     assert(ios.width() == 0);
   16722                                 }
   16723                                 ios.width(25);
   16724                                 right(ios);
   16725                                 {
   16726                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16727                                     std::string ex(str, iter.base());
   16728                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16729                                     assert(ios.width() == 0);
   16730                                 }
   16731                                 ios.width(25);
   16732                                 internal(ios);
   16733                                 {
   16734                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16735                                     std::string ex(str, iter.base());
   16736                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16737                                     assert(ios.width() == 0);
   16738                                 }
   16739                             }
   16740                         }
   16741                         showpoint(ios);
   16742                         {
   16743                             ios.imbue(lc);
   16744                             {
   16745                                 ios.width(0);
   16746                                 {
   16747                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16748                                     std::string ex(str, iter.base());
   16749                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16750                                     assert(ios.width() == 0);
   16751                                 }
   16752                                 ios.width(25);
   16753                                 left(ios);
   16754                                 {
   16755                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16756                                     std::string ex(str, iter.base());
   16757                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16758                                     assert(ios.width() == 0);
   16759                                 }
   16760                                 ios.width(25);
   16761                                 right(ios);
   16762                                 {
   16763                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16764                                     std::string ex(str, iter.base());
   16765                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16766                                     assert(ios.width() == 0);
   16767                                 }
   16768                                 ios.width(25);
   16769                                 internal(ios);
   16770                                 {
   16771                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16772                                     std::string ex(str, iter.base());
   16773                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16774                                     assert(ios.width() == 0);
   16775                                 }
   16776                             }
   16777                             ios.imbue(lg);
   16778                             {
   16779                                 ios.width(0);
   16780                                 {
   16781                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16782                                     std::string ex(str, iter.base());
   16783                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16784                                     assert(ios.width() == 0);
   16785                                 }
   16786                                 ios.width(25);
   16787                                 left(ios);
   16788                                 {
   16789                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16790                                     std::string ex(str, iter.base());
   16791                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16792                                     assert(ios.width() == 0);
   16793                                 }
   16794                                 ios.width(25);
   16795                                 right(ios);
   16796                                 {
   16797                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16798                                     std::string ex(str, iter.base());
   16799                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16800                                     assert(ios.width() == 0);
   16801                                 }
   16802                                 ios.width(25);
   16803                                 internal(ios);
   16804                                 {
   16805                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16806                                     std::string ex(str, iter.base());
   16807                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16808                                     assert(ios.width() == 0);
   16809                                 }
   16810                             }
   16811                         }
   16812                     }
   16813                     showpos(ios);
   16814                     {
   16815                         noshowpoint(ios);
   16816                         {
   16817                             ios.imbue(lc);
   16818                             {
   16819                                 ios.width(0);
   16820                                 {
   16821                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16822                                     std::string ex(str, iter.base());
   16823                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16824                                     assert(ios.width() == 0);
   16825                                 }
   16826                                 ios.width(25);
   16827                                 left(ios);
   16828                                 {
   16829                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16830                                     std::string ex(str, iter.base());
   16831                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16832                                     assert(ios.width() == 0);
   16833                                 }
   16834                                 ios.width(25);
   16835                                 right(ios);
   16836                                 {
   16837                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16838                                     std::string ex(str, iter.base());
   16839                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16840                                     assert(ios.width() == 0);
   16841                                 }
   16842                                 ios.width(25);
   16843                                 internal(ios);
   16844                                 {
   16845                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16846                                     std::string ex(str, iter.base());
   16847                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16848                                     assert(ios.width() == 0);
   16849                                 }
   16850                             }
   16851                             ios.imbue(lg);
   16852                             {
   16853                                 ios.width(0);
   16854                                 {
   16855                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16856                                     std::string ex(str, iter.base());
   16857                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16858                                     assert(ios.width() == 0);
   16859                                 }
   16860                                 ios.width(25);
   16861                                 left(ios);
   16862                                 {
   16863                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16864                                     std::string ex(str, iter.base());
   16865                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16866                                     assert(ios.width() == 0);
   16867                                 }
   16868                                 ios.width(25);
   16869                                 right(ios);
   16870                                 {
   16871                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16872                                     std::string ex(str, iter.base());
   16873                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16874                                     assert(ios.width() == 0);
   16875                                 }
   16876                                 ios.width(25);
   16877                                 internal(ios);
   16878                                 {
   16879                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16880                                     std::string ex(str, iter.base());
   16881                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16882                                     assert(ios.width() == 0);
   16883                                 }
   16884                             }
   16885                         }
   16886                         showpoint(ios);
   16887                         {
   16888                             ios.imbue(lc);
   16889                             {
   16890                                 ios.width(0);
   16891                                 {
   16892                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16893                                     std::string ex(str, iter.base());
   16894                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16895                                     assert(ios.width() == 0);
   16896                                 }
   16897                                 ios.width(25);
   16898                                 left(ios);
   16899                                 {
   16900                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16901                                     std::string ex(str, iter.base());
   16902                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16903                                     assert(ios.width() == 0);
   16904                                 }
   16905                                 ios.width(25);
   16906                                 right(ios);
   16907                                 {
   16908                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16909                                     std::string ex(str, iter.base());
   16910                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16911                                     assert(ios.width() == 0);
   16912                                 }
   16913                                 ios.width(25);
   16914                                 internal(ios);
   16915                                 {
   16916                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16917                                     std::string ex(str, iter.base());
   16918                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16919                                     assert(ios.width() == 0);
   16920                                 }
   16921                             }
   16922                             ios.imbue(lg);
   16923                             {
   16924                                 ios.width(0);
   16925                                 {
   16926                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16927                                     std::string ex(str, iter.base());
   16928                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16929                                     assert(ios.width() == 0);
   16930                                 }
   16931                                 ios.width(25);
   16932                                 left(ios);
   16933                                 {
   16934                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16935                                     std::string ex(str, iter.base());
   16936                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16937                                     assert(ios.width() == 0);
   16938                                 }
   16939                                 ios.width(25);
   16940                                 right(ios);
   16941                                 {
   16942                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16943                                     std::string ex(str, iter.base());
   16944                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16945                                     assert(ios.width() == 0);
   16946                                 }
   16947                                 ios.width(25);
   16948                                 internal(ios);
   16949                                 {
   16950                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16951                                     std::string ex(str, iter.base());
   16952                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16953                                     assert(ios.width() == 0);
   16954                                 }
   16955                             }
   16956                         }
   16957                     }
   16958                 }
   16959                 uppercase(ios);
   16960                 {
   16961                     noshowpos(ios);
   16962                     {
   16963                         noshowpoint(ios);
   16964                         {
   16965                             ios.imbue(lc);
   16966                             {
   16967                                 ios.width(0);
   16968                                 {
   16969                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16970                                     std::string ex(str, iter.base());
   16971                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16972                                     assert(ios.width() == 0);
   16973                                 }
   16974                                 ios.width(25);
   16975                                 left(ios);
   16976                                 {
   16977                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16978                                     std::string ex(str, iter.base());
   16979                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16980                                     assert(ios.width() == 0);
   16981                                 }
   16982                                 ios.width(25);
   16983                                 right(ios);
   16984                                 {
   16985                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16986                                     std::string ex(str, iter.base());
   16987                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16988                                     assert(ios.width() == 0);
   16989                                 }
   16990                                 ios.width(25);
   16991                                 internal(ios);
   16992                                 {
   16993                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16994                                     std::string ex(str, iter.base());
   16995                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16996                                     assert(ios.width() == 0);
   16997                                 }
   16998                             }
   16999                             ios.imbue(lg);
   17000                             {
   17001                                 ios.width(0);
   17002                                 {
   17003                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17004                                     std::string ex(str, iter.base());
   17005                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17006                                     assert(ios.width() == 0);
   17007                                 }
   17008                                 ios.width(25);
   17009                                 left(ios);
   17010                                 {
   17011                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17012                                     std::string ex(str, iter.base());
   17013                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17014                                     assert(ios.width() == 0);
   17015                                 }
   17016                                 ios.width(25);
   17017                                 right(ios);
   17018                                 {
   17019                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17020                                     std::string ex(str, iter.base());
   17021                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17022                                     assert(ios.width() == 0);
   17023                                 }
   17024                                 ios.width(25);
   17025                                 internal(ios);
   17026                                 {
   17027                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17028                                     std::string ex(str, iter.base());
   17029                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17030                                     assert(ios.width() == 0);
   17031                                 }
   17032                             }
   17033                         }
   17034                         showpoint(ios);
   17035                         {
   17036                             ios.imbue(lc);
   17037                             {
   17038                                 ios.width(0);
   17039                                 {
   17040                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17041                                     std::string ex(str, iter.base());
   17042                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17043                                     assert(ios.width() == 0);
   17044                                 }
   17045                                 ios.width(25);
   17046                                 left(ios);
   17047                                 {
   17048                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17049                                     std::string ex(str, iter.base());
   17050                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17051                                     assert(ios.width() == 0);
   17052                                 }
   17053                                 ios.width(25);
   17054                                 right(ios);
   17055                                 {
   17056                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17057                                     std::string ex(str, iter.base());
   17058                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17059                                     assert(ios.width() == 0);
   17060                                 }
   17061                                 ios.width(25);
   17062                                 internal(ios);
   17063                                 {
   17064                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17065                                     std::string ex(str, iter.base());
   17066                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17067                                     assert(ios.width() == 0);
   17068                                 }
   17069                             }
   17070                             ios.imbue(lg);
   17071                             {
   17072                                 ios.width(0);
   17073                                 {
   17074                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17075                                     std::string ex(str, iter.base());
   17076                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17077                                     assert(ios.width() == 0);
   17078                                 }
   17079                                 ios.width(25);
   17080                                 left(ios);
   17081                                 {
   17082                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17083                                     std::string ex(str, iter.base());
   17084                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17085                                     assert(ios.width() == 0);
   17086                                 }
   17087                                 ios.width(25);
   17088                                 right(ios);
   17089                                 {
   17090                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17091                                     std::string ex(str, iter.base());
   17092                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17093                                     assert(ios.width() == 0);
   17094                                 }
   17095                                 ios.width(25);
   17096                                 internal(ios);
   17097                                 {
   17098                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17099                                     std::string ex(str, iter.base());
   17100                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17101                                     assert(ios.width() == 0);
   17102                                 }
   17103                             }
   17104                         }
   17105                     }
   17106                     showpos(ios);
   17107                     {
   17108                         noshowpoint(ios);
   17109                         {
   17110                             ios.imbue(lc);
   17111                             {
   17112                                 ios.width(0);
   17113                                 {
   17114                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17115                                     std::string ex(str, iter.base());
   17116                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17117                                     assert(ios.width() == 0);
   17118                                 }
   17119                                 ios.width(25);
   17120                                 left(ios);
   17121                                 {
   17122                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17123                                     std::string ex(str, iter.base());
   17124                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17125                                     assert(ios.width() == 0);
   17126                                 }
   17127                                 ios.width(25);
   17128                                 right(ios);
   17129                                 {
   17130                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17131                                     std::string ex(str, iter.base());
   17132                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17133                                     assert(ios.width() == 0);
   17134                                 }
   17135                                 ios.width(25);
   17136                                 internal(ios);
   17137                                 {
   17138                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17139                                     std::string ex(str, iter.base());
   17140                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17141                                     assert(ios.width() == 0);
   17142                                 }
   17143                             }
   17144                             ios.imbue(lg);
   17145                             {
   17146                                 ios.width(0);
   17147                                 {
   17148                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17149                                     std::string ex(str, iter.base());
   17150                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17151                                     assert(ios.width() == 0);
   17152                                 }
   17153                                 ios.width(25);
   17154                                 left(ios);
   17155                                 {
   17156                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17157                                     std::string ex(str, iter.base());
   17158                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17159                                     assert(ios.width() == 0);
   17160                                 }
   17161                                 ios.width(25);
   17162                                 right(ios);
   17163                                 {
   17164                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17165                                     std::string ex(str, iter.base());
   17166                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17167                                     assert(ios.width() == 0);
   17168                                 }
   17169                                 ios.width(25);
   17170                                 internal(ios);
   17171                                 {
   17172                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17173                                     std::string ex(str, iter.base());
   17174                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17175                                     assert(ios.width() == 0);
   17176                                 }
   17177                             }
   17178                         }
   17179                         showpoint(ios);
   17180                         {
   17181                             ios.imbue(lc);
   17182                             {
   17183                                 ios.width(0);
   17184                                 {
   17185                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17186                                     std::string ex(str, iter.base());
   17187                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17188                                     assert(ios.width() == 0);
   17189                                 }
   17190                                 ios.width(25);
   17191                                 left(ios);
   17192                                 {
   17193                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17194                                     std::string ex(str, iter.base());
   17195                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17196                                     assert(ios.width() == 0);
   17197                                 }
   17198                                 ios.width(25);
   17199                                 right(ios);
   17200                                 {
   17201                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17202                                     std::string ex(str, iter.base());
   17203                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17204                                     assert(ios.width() == 0);
   17205                                 }
   17206                                 ios.width(25);
   17207                                 internal(ios);
   17208                                 {
   17209                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17210                                     std::string ex(str, iter.base());
   17211                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17212                                     assert(ios.width() == 0);
   17213                                 }
   17214                             }
   17215                             ios.imbue(lg);
   17216                             {
   17217                                 ios.width(0);
   17218                                 {
   17219                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17220                                     std::string ex(str, iter.base());
   17221                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17222                                     assert(ios.width() == 0);
   17223                                 }
   17224                                 ios.width(25);
   17225                                 left(ios);
   17226                                 {
   17227                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17228                                     std::string ex(str, iter.base());
   17229                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17230                                     assert(ios.width() == 0);
   17231                                 }
   17232                                 ios.width(25);
   17233                                 right(ios);
   17234                                 {
   17235                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17236                                     std::string ex(str, iter.base());
   17237                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17238                                     assert(ios.width() == 0);
   17239                                 }
   17240                                 ios.width(25);
   17241                                 internal(ios);
   17242                                 {
   17243                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17244                                     std::string ex(str, iter.base());
   17245                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17246                                     assert(ios.width() == 0);
   17247                                 }
   17248                             }
   17249                         }
   17250                     }
   17251                 }
   17252             }
   17253         }
   17254     }
   17255 }
   17256 
   17257 void test8()
   17258 {
   17259     char str[200];
   17260     output_iterator<char*> iter;
   17261     std::locale lc = std::locale::classic();
   17262     std::locale lg(lc, new my_numpunct);
   17263     const my_facet f(1);
   17264     {
   17265         long double v = 1234567890.125;
   17266         std::ios ios(0);
   17267         fixed(ios);
   17268         // %f
   17269         {
   17270             ios.precision(0);
   17271             {
   17272                 nouppercase(ios);
   17273                 {
   17274                     noshowpos(ios);
   17275                     {
   17276                         noshowpoint(ios);
   17277                         {
   17278                             ios.imbue(lc);
   17279                             {
   17280                                 ios.width(0);
   17281                                 {
   17282                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17283                                     std::string ex(str, iter.base());
   17284                                     assert(ex == "1234567890");
   17285                                     assert(ios.width() == 0);
   17286                                 }
   17287                                 ios.width(25);
   17288                                 left(ios);
   17289                                 {
   17290                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17291                                     std::string ex(str, iter.base());
   17292                                     assert(ex == "1234567890***************");
   17293                                     assert(ios.width() == 0);
   17294                                 }
   17295                                 ios.width(25);
   17296                                 right(ios);
   17297                                 {
   17298                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17299                                     std::string ex(str, iter.base());
   17300                                     assert(ex == "***************1234567890");
   17301                                     assert(ios.width() == 0);
   17302                                 }
   17303                                 ios.width(25);
   17304                                 internal(ios);
   17305                                 {
   17306                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17307                                     std::string ex(str, iter.base());
   17308                                     assert(ex == "***************1234567890");
   17309                                     assert(ios.width() == 0);
   17310                                 }
   17311                             }
   17312                             ios.imbue(lg);
   17313                             {
   17314                                 ios.width(0);
   17315                                 {
   17316                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17317                                     std::string ex(str, iter.base());
   17318                                     assert(ex == "1_234_567_89_0");
   17319                                     assert(ios.width() == 0);
   17320                                 }
   17321                                 ios.width(25);
   17322                                 left(ios);
   17323                                 {
   17324                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17325                                     std::string ex(str, iter.base());
   17326                                     assert(ex == "1_234_567_89_0***********");
   17327                                     assert(ios.width() == 0);
   17328                                 }
   17329                                 ios.width(25);
   17330                                 right(ios);
   17331                                 {
   17332                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17333                                     std::string ex(str, iter.base());
   17334                                     assert(ex == "***********1_234_567_89_0");
   17335                                     assert(ios.width() == 0);
   17336                                 }
   17337                                 ios.width(25);
   17338                                 internal(ios);
   17339                                 {
   17340                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17341                                     std::string ex(str, iter.base());
   17342                                     assert(ex == "***********1_234_567_89_0");
   17343                                     assert(ios.width() == 0);
   17344                                 }
   17345                             }
   17346                         }
   17347                         showpoint(ios);
   17348                         {
   17349                             ios.imbue(lc);
   17350                             {
   17351                                 ios.width(0);
   17352                                 {
   17353                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17354                                     std::string ex(str, iter.base());
   17355                                     assert(ex == "1234567890.");
   17356                                     assert(ios.width() == 0);
   17357                                 }
   17358                                 ios.width(25);
   17359                                 left(ios);
   17360                                 {
   17361                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17362                                     std::string ex(str, iter.base());
   17363                                     assert(ex == "1234567890.**************");
   17364                                     assert(ios.width() == 0);
   17365                                 }
   17366                                 ios.width(25);
   17367                                 right(ios);
   17368                                 {
   17369                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17370                                     std::string ex(str, iter.base());
   17371                                     assert(ex == "**************1234567890.");
   17372                                     assert(ios.width() == 0);
   17373                                 }
   17374                                 ios.width(25);
   17375                                 internal(ios);
   17376                                 {
   17377                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17378                                     std::string ex(str, iter.base());
   17379                                     assert(ex == "**************1234567890.");
   17380                                     assert(ios.width() == 0);
   17381                                 }
   17382                             }
   17383                             ios.imbue(lg);
   17384                             {
   17385                                 ios.width(0);
   17386                                 {
   17387                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17388                                     std::string ex(str, iter.base());
   17389                                     assert(ex == "1_234_567_89_0;");
   17390                                     assert(ios.width() == 0);
   17391                                 }
   17392                                 ios.width(25);
   17393                                 left(ios);
   17394                                 {
   17395                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17396                                     std::string ex(str, iter.base());
   17397                                     assert(ex == "1_234_567_89_0;**********");
   17398                                     assert(ios.width() == 0);
   17399                                 }
   17400                                 ios.width(25);
   17401                                 right(ios);
   17402                                 {
   17403                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17404                                     std::string ex(str, iter.base());
   17405                                     assert(ex == "**********1_234_567_89_0;");
   17406                                     assert(ios.width() == 0);
   17407                                 }
   17408                                 ios.width(25);
   17409                                 internal(ios);
   17410                                 {
   17411                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17412                                     std::string ex(str, iter.base());
   17413                                     assert(ex == "**********1_234_567_89_0;");
   17414                                     assert(ios.width() == 0);
   17415                                 }
   17416                             }
   17417                         }
   17418                     }
   17419                     showpos(ios);
   17420                     {
   17421                         noshowpoint(ios);
   17422                         {
   17423                             ios.imbue(lc);
   17424                             {
   17425                                 ios.width(0);
   17426                                 {
   17427                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17428                                     std::string ex(str, iter.base());
   17429                                     assert(ex == "+1234567890");
   17430                                     assert(ios.width() == 0);
   17431                                 }
   17432                                 ios.width(25);
   17433                                 left(ios);
   17434                                 {
   17435                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17436                                     std::string ex(str, iter.base());
   17437                                     assert(ex == "+1234567890**************");
   17438                                     assert(ios.width() == 0);
   17439                                 }
   17440                                 ios.width(25);
   17441                                 right(ios);
   17442                                 {
   17443                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17444                                     std::string ex(str, iter.base());
   17445                                     assert(ex == "**************+1234567890");
   17446                                     assert(ios.width() == 0);
   17447                                 }
   17448                                 ios.width(25);
   17449                                 internal(ios);
   17450                                 {
   17451                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17452                                     std::string ex(str, iter.base());
   17453                                     assert(ex == "+**************1234567890");
   17454                                     assert(ios.width() == 0);
   17455                                 }
   17456                             }
   17457                             ios.imbue(lg);
   17458                             {
   17459                                 ios.width(0);
   17460                                 {
   17461                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17462                                     std::string ex(str, iter.base());
   17463                                     assert(ex == "+1_234_567_89_0");
   17464                                     assert(ios.width() == 0);
   17465                                 }
   17466                                 ios.width(25);
   17467                                 left(ios);
   17468                                 {
   17469                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17470                                     std::string ex(str, iter.base());
   17471                                     assert(ex == "+1_234_567_89_0**********");
   17472                                     assert(ios.width() == 0);
   17473                                 }
   17474                                 ios.width(25);
   17475                                 right(ios);
   17476                                 {
   17477                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17478                                     std::string ex(str, iter.base());
   17479                                     assert(ex == "**********+1_234_567_89_0");
   17480                                     assert(ios.width() == 0);
   17481                                 }
   17482                                 ios.width(25);
   17483                                 internal(ios);
   17484                                 {
   17485                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17486                                     std::string ex(str, iter.base());
   17487                                     assert(ex == "+**********1_234_567_89_0");
   17488                                     assert(ios.width() == 0);
   17489                                 }
   17490                             }
   17491                         }
   17492                         showpoint(ios);
   17493                         {
   17494                             ios.imbue(lc);
   17495                             {
   17496                                 ios.width(0);
   17497                                 {
   17498                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17499                                     std::string ex(str, iter.base());
   17500                                     assert(ex == "+1234567890.");
   17501                                     assert(ios.width() == 0);
   17502                                 }
   17503                                 ios.width(25);
   17504                                 left(ios);
   17505                                 {
   17506                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17507                                     std::string ex(str, iter.base());
   17508                                     assert(ex == "+1234567890.*************");
   17509                                     assert(ios.width() == 0);
   17510                                 }
   17511                                 ios.width(25);
   17512                                 right(ios);
   17513                                 {
   17514                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17515                                     std::string ex(str, iter.base());
   17516                                     assert(ex == "*************+1234567890.");
   17517                                     assert(ios.width() == 0);
   17518                                 }
   17519                                 ios.width(25);
   17520                                 internal(ios);
   17521                                 {
   17522                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17523                                     std::string ex(str, iter.base());
   17524                                     assert(ex == "+*************1234567890.");
   17525                                     assert(ios.width() == 0);
   17526                                 }
   17527                             }
   17528                             ios.imbue(lg);
   17529                             {
   17530                                 ios.width(0);
   17531                                 {
   17532                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17533                                     std::string ex(str, iter.base());
   17534                                     assert(ex == "+1_234_567_89_0;");
   17535                                     assert(ios.width() == 0);
   17536                                 }
   17537                                 ios.width(25);
   17538                                 left(ios);
   17539                                 {
   17540                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17541                                     std::string ex(str, iter.base());
   17542                                     assert(ex == "+1_234_567_89_0;*********");
   17543                                     assert(ios.width() == 0);
   17544                                 }
   17545                                 ios.width(25);
   17546                                 right(ios);
   17547                                 {
   17548                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17549                                     std::string ex(str, iter.base());
   17550                                     assert(ex == "*********+1_234_567_89_0;");
   17551                                     assert(ios.width() == 0);
   17552                                 }
   17553                                 ios.width(25);
   17554                                 internal(ios);
   17555                                 {
   17556                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17557                                     std::string ex(str, iter.base());
   17558                                     assert(ex == "+*********1_234_567_89_0;");
   17559                                     assert(ios.width() == 0);
   17560                                 }
   17561                             }
   17562                         }
   17563                     }
   17564                 }
   17565                 uppercase(ios);
   17566                 {
   17567                     noshowpos(ios);
   17568                     {
   17569                         noshowpoint(ios);
   17570                         {
   17571                             ios.imbue(lc);
   17572                             {
   17573                                 ios.width(0);
   17574                                 {
   17575                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17576                                     std::string ex(str, iter.base());
   17577                                     assert(ex == "1234567890");
   17578                                     assert(ios.width() == 0);
   17579                                 }
   17580                                 ios.width(25);
   17581                                 left(ios);
   17582                                 {
   17583                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17584                                     std::string ex(str, iter.base());
   17585                                     assert(ex == "1234567890***************");
   17586                                     assert(ios.width() == 0);
   17587                                 }
   17588                                 ios.width(25);
   17589                                 right(ios);
   17590                                 {
   17591                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17592                                     std::string ex(str, iter.base());
   17593                                     assert(ex == "***************1234567890");
   17594                                     assert(ios.width() == 0);
   17595                                 }
   17596                                 ios.width(25);
   17597                                 internal(ios);
   17598                                 {
   17599                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17600                                     std::string ex(str, iter.base());
   17601                                     assert(ex == "***************1234567890");
   17602                                     assert(ios.width() == 0);
   17603                                 }
   17604                             }
   17605                             ios.imbue(lg);
   17606                             {
   17607                                 ios.width(0);
   17608                                 {
   17609                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17610                                     std::string ex(str, iter.base());
   17611                                     assert(ex == "1_234_567_89_0");
   17612                                     assert(ios.width() == 0);
   17613                                 }
   17614                                 ios.width(25);
   17615                                 left(ios);
   17616                                 {
   17617                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17618                                     std::string ex(str, iter.base());
   17619                                     assert(ex == "1_234_567_89_0***********");
   17620                                     assert(ios.width() == 0);
   17621                                 }
   17622                                 ios.width(25);
   17623                                 right(ios);
   17624                                 {
   17625                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17626                                     std::string ex(str, iter.base());
   17627                                     assert(ex == "***********1_234_567_89_0");
   17628                                     assert(ios.width() == 0);
   17629                                 }
   17630                                 ios.width(25);
   17631                                 internal(ios);
   17632                                 {
   17633                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17634                                     std::string ex(str, iter.base());
   17635                                     assert(ex == "***********1_234_567_89_0");
   17636                                     assert(ios.width() == 0);
   17637                                 }
   17638                             }
   17639                         }
   17640                         showpoint(ios);
   17641                         {
   17642                             ios.imbue(lc);
   17643                             {
   17644                                 ios.width(0);
   17645                                 {
   17646                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17647                                     std::string ex(str, iter.base());
   17648                                     assert(ex == "1234567890.");
   17649                                     assert(ios.width() == 0);
   17650                                 }
   17651                                 ios.width(25);
   17652                                 left(ios);
   17653                                 {
   17654                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17655                                     std::string ex(str, iter.base());
   17656                                     assert(ex == "1234567890.**************");
   17657                                     assert(ios.width() == 0);
   17658                                 }
   17659                                 ios.width(25);
   17660                                 right(ios);
   17661                                 {
   17662                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17663                                     std::string ex(str, iter.base());
   17664                                     assert(ex == "**************1234567890.");
   17665                                     assert(ios.width() == 0);
   17666                                 }
   17667                                 ios.width(25);
   17668                                 internal(ios);
   17669                                 {
   17670                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17671                                     std::string ex(str, iter.base());
   17672                                     assert(ex == "**************1234567890.");
   17673                                     assert(ios.width() == 0);
   17674                                 }
   17675                             }
   17676                             ios.imbue(lg);
   17677                             {
   17678                                 ios.width(0);
   17679                                 {
   17680                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17681                                     std::string ex(str, iter.base());
   17682                                     assert(ex == "1_234_567_89_0;");
   17683                                     assert(ios.width() == 0);
   17684                                 }
   17685                                 ios.width(25);
   17686                                 left(ios);
   17687                                 {
   17688                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17689                                     std::string ex(str, iter.base());
   17690                                     assert(ex == "1_234_567_89_0;**********");
   17691                                     assert(ios.width() == 0);
   17692                                 }
   17693                                 ios.width(25);
   17694                                 right(ios);
   17695                                 {
   17696                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17697                                     std::string ex(str, iter.base());
   17698                                     assert(ex == "**********1_234_567_89_0;");
   17699                                     assert(ios.width() == 0);
   17700                                 }
   17701                                 ios.width(25);
   17702                                 internal(ios);
   17703                                 {
   17704                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17705                                     std::string ex(str, iter.base());
   17706                                     assert(ex == "**********1_234_567_89_0;");
   17707                                     assert(ios.width() == 0);
   17708                                 }
   17709                             }
   17710                         }
   17711                     }
   17712                     showpos(ios);
   17713                     {
   17714                         noshowpoint(ios);
   17715                         {
   17716                             ios.imbue(lc);
   17717                             {
   17718                                 ios.width(0);
   17719                                 {
   17720                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17721                                     std::string ex(str, iter.base());
   17722                                     assert(ex == "+1234567890");
   17723                                     assert(ios.width() == 0);
   17724                                 }
   17725                                 ios.width(25);
   17726                                 left(ios);
   17727                                 {
   17728                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17729                                     std::string ex(str, iter.base());
   17730                                     assert(ex == "+1234567890**************");
   17731                                     assert(ios.width() == 0);
   17732                                 }
   17733                                 ios.width(25);
   17734                                 right(ios);
   17735                                 {
   17736                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17737                                     std::string ex(str, iter.base());
   17738                                     assert(ex == "**************+1234567890");
   17739                                     assert(ios.width() == 0);
   17740                                 }
   17741                                 ios.width(25);
   17742                                 internal(ios);
   17743                                 {
   17744                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17745                                     std::string ex(str, iter.base());
   17746                                     assert(ex == "+**************1234567890");
   17747                                     assert(ios.width() == 0);
   17748                                 }
   17749                             }
   17750                             ios.imbue(lg);
   17751                             {
   17752                                 ios.width(0);
   17753                                 {
   17754                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17755                                     std::string ex(str, iter.base());
   17756                                     assert(ex == "+1_234_567_89_0");
   17757                                     assert(ios.width() == 0);
   17758                                 }
   17759                                 ios.width(25);
   17760                                 left(ios);
   17761                                 {
   17762                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17763                                     std::string ex(str, iter.base());
   17764                                     assert(ex == "+1_234_567_89_0**********");
   17765                                     assert(ios.width() == 0);
   17766                                 }
   17767                                 ios.width(25);
   17768                                 right(ios);
   17769                                 {
   17770                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17771                                     std::string ex(str, iter.base());
   17772                                     assert(ex == "**********+1_234_567_89_0");
   17773                                     assert(ios.width() == 0);
   17774                                 }
   17775                                 ios.width(25);
   17776                                 internal(ios);
   17777                                 {
   17778                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17779                                     std::string ex(str, iter.base());
   17780                                     assert(ex == "+**********1_234_567_89_0");
   17781                                     assert(ios.width() == 0);
   17782                                 }
   17783                             }
   17784                         }
   17785                         showpoint(ios);
   17786                         {
   17787                             ios.imbue(lc);
   17788                             {
   17789                                 ios.width(0);
   17790                                 {
   17791                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17792                                     std::string ex(str, iter.base());
   17793                                     assert(ex == "+1234567890.");
   17794                                     assert(ios.width() == 0);
   17795                                 }
   17796                                 ios.width(25);
   17797                                 left(ios);
   17798                                 {
   17799                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17800                                     std::string ex(str, iter.base());
   17801                                     assert(ex == "+1234567890.*************");
   17802                                     assert(ios.width() == 0);
   17803                                 }
   17804                                 ios.width(25);
   17805                                 right(ios);
   17806                                 {
   17807                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17808                                     std::string ex(str, iter.base());
   17809                                     assert(ex == "*************+1234567890.");
   17810                                     assert(ios.width() == 0);
   17811                                 }
   17812                                 ios.width(25);
   17813                                 internal(ios);
   17814                                 {
   17815                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17816                                     std::string ex(str, iter.base());
   17817                                     assert(ex == "+*************1234567890.");
   17818                                     assert(ios.width() == 0);
   17819                                 }
   17820                             }
   17821                             ios.imbue(lg);
   17822                             {
   17823                                 ios.width(0);
   17824                                 {
   17825                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17826                                     std::string ex(str, iter.base());
   17827                                     assert(ex == "+1_234_567_89_0;");
   17828                                     assert(ios.width() == 0);
   17829                                 }
   17830                                 ios.width(25);
   17831                                 left(ios);
   17832                                 {
   17833                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17834                                     std::string ex(str, iter.base());
   17835                                     assert(ex == "+1_234_567_89_0;*********");
   17836                                     assert(ios.width() == 0);
   17837                                 }
   17838                                 ios.width(25);
   17839                                 right(ios);
   17840                                 {
   17841                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17842                                     std::string ex(str, iter.base());
   17843                                     assert(ex == "*********+1_234_567_89_0;");
   17844                                     assert(ios.width() == 0);
   17845                                 }
   17846                                 ios.width(25);
   17847                                 internal(ios);
   17848                                 {
   17849                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17850                                     std::string ex(str, iter.base());
   17851                                     assert(ex == "+*********1_234_567_89_0;");
   17852                                     assert(ios.width() == 0);
   17853                                 }
   17854                             }
   17855                         }
   17856                     }
   17857                 }
   17858             }
   17859             ios.precision(1);
   17860             {
   17861                 nouppercase(ios);
   17862                 {
   17863                     noshowpos(ios);
   17864                     {
   17865                         noshowpoint(ios);
   17866                         {
   17867                             ios.imbue(lc);
   17868                             {
   17869                                 ios.width(0);
   17870                                 {
   17871                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17872                                     std::string ex(str, iter.base());
   17873                                     assert(ex == "1234567890.1");
   17874                                     assert(ios.width() == 0);
   17875                                 }
   17876                                 ios.width(25);
   17877                                 left(ios);
   17878                                 {
   17879                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17880                                     std::string ex(str, iter.base());
   17881                                     assert(ex == "1234567890.1*************");
   17882                                     assert(ios.width() == 0);
   17883                                 }
   17884                                 ios.width(25);
   17885                                 right(ios);
   17886                                 {
   17887                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17888                                     std::string ex(str, iter.base());
   17889                                     assert(ex == "*************1234567890.1");
   17890                                     assert(ios.width() == 0);
   17891                                 }
   17892                                 ios.width(25);
   17893                                 internal(ios);
   17894                                 {
   17895                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17896                                     std::string ex(str, iter.base());
   17897                                     assert(ex == "*************1234567890.1");
   17898                                     assert(ios.width() == 0);
   17899                                 }
   17900                             }
   17901                             ios.imbue(lg);
   17902                             {
   17903                                 ios.width(0);
   17904                                 {
   17905                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17906                                     std::string ex(str, iter.base());
   17907                                     assert(ex == "1_234_567_89_0;1");
   17908                                     assert(ios.width() == 0);
   17909                                 }
   17910                                 ios.width(25);
   17911                                 left(ios);
   17912                                 {
   17913                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17914                                     std::string ex(str, iter.base());
   17915                                     assert(ex == "1_234_567_89_0;1*********");
   17916                                     assert(ios.width() == 0);
   17917                                 }
   17918                                 ios.width(25);
   17919                                 right(ios);
   17920                                 {
   17921                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17922                                     std::string ex(str, iter.base());
   17923                                     assert(ex == "*********1_234_567_89_0;1");
   17924                                     assert(ios.width() == 0);
   17925                                 }
   17926                                 ios.width(25);
   17927                                 internal(ios);
   17928                                 {
   17929                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17930                                     std::string ex(str, iter.base());
   17931                                     assert(ex == "*********1_234_567_89_0;1");
   17932                                     assert(ios.width() == 0);
   17933                                 }
   17934                             }
   17935                         }
   17936                         showpoint(ios);
   17937                         {
   17938                             ios.imbue(lc);
   17939                             {
   17940                                 ios.width(0);
   17941                                 {
   17942                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17943                                     std::string ex(str, iter.base());
   17944                                     assert(ex == "1234567890.1");
   17945                                     assert(ios.width() == 0);
   17946                                 }
   17947                                 ios.width(25);
   17948                                 left(ios);
   17949                                 {
   17950                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17951                                     std::string ex(str, iter.base());
   17952                                     assert(ex == "1234567890.1*************");
   17953                                     assert(ios.width() == 0);
   17954                                 }
   17955                                 ios.width(25);
   17956                                 right(ios);
   17957                                 {
   17958                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17959                                     std::string ex(str, iter.base());
   17960                                     assert(ex == "*************1234567890.1");
   17961                                     assert(ios.width() == 0);
   17962                                 }
   17963                                 ios.width(25);
   17964                                 internal(ios);
   17965                                 {
   17966                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17967                                     std::string ex(str, iter.base());
   17968                                     assert(ex == "*************1234567890.1");
   17969                                     assert(ios.width() == 0);
   17970                                 }
   17971                             }
   17972                             ios.imbue(lg);
   17973                             {
   17974                                 ios.width(0);
   17975                                 {
   17976                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17977                                     std::string ex(str, iter.base());
   17978                                     assert(ex == "1_234_567_89_0;1");
   17979                                     assert(ios.width() == 0);
   17980                                 }
   17981                                 ios.width(25);
   17982                                 left(ios);
   17983                                 {
   17984                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17985                                     std::string ex(str, iter.base());
   17986                                     assert(ex == "1_234_567_89_0;1*********");
   17987                                     assert(ios.width() == 0);
   17988                                 }
   17989                                 ios.width(25);
   17990                                 right(ios);
   17991                                 {
   17992                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17993                                     std::string ex(str, iter.base());
   17994                                     assert(ex == "*********1_234_567_89_0;1");
   17995                                     assert(ios.width() == 0);
   17996                                 }
   17997                                 ios.width(25);
   17998                                 internal(ios);
   17999                                 {
   18000                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18001                                     std::string ex(str, iter.base());
   18002                                     assert(ex == "*********1_234_567_89_0;1");
   18003                                     assert(ios.width() == 0);
   18004                                 }
   18005                             }
   18006                         }
   18007                     }
   18008                     showpos(ios);
   18009                     {
   18010                         noshowpoint(ios);
   18011                         {
   18012                             ios.imbue(lc);
   18013                             {
   18014                                 ios.width(0);
   18015                                 {
   18016                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18017                                     std::string ex(str, iter.base());
   18018                                     assert(ex == "+1234567890.1");
   18019                                     assert(ios.width() == 0);
   18020                                 }
   18021                                 ios.width(25);
   18022                                 left(ios);
   18023                                 {
   18024                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18025                                     std::string ex(str, iter.base());
   18026                                     assert(ex == "+1234567890.1************");
   18027                                     assert(ios.width() == 0);
   18028                                 }
   18029                                 ios.width(25);
   18030                                 right(ios);
   18031                                 {
   18032                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18033                                     std::string ex(str, iter.base());
   18034                                     assert(ex == "************+1234567890.1");
   18035                                     assert(ios.width() == 0);
   18036                                 }
   18037                                 ios.width(25);
   18038                                 internal(ios);
   18039                                 {
   18040                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18041                                     std::string ex(str, iter.base());
   18042                                     assert(ex == "+************1234567890.1");
   18043                                     assert(ios.width() == 0);
   18044                                 }
   18045                             }
   18046                             ios.imbue(lg);
   18047                             {
   18048                                 ios.width(0);
   18049                                 {
   18050                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18051                                     std::string ex(str, iter.base());
   18052                                     assert(ex == "+1_234_567_89_0;1");
   18053                                     assert(ios.width() == 0);
   18054                                 }
   18055                                 ios.width(25);
   18056                                 left(ios);
   18057                                 {
   18058                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18059                                     std::string ex(str, iter.base());
   18060                                     assert(ex == "+1_234_567_89_0;1********");
   18061                                     assert(ios.width() == 0);
   18062                                 }
   18063                                 ios.width(25);
   18064                                 right(ios);
   18065                                 {
   18066                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18067                                     std::string ex(str, iter.base());
   18068                                     assert(ex == "********+1_234_567_89_0;1");
   18069                                     assert(ios.width() == 0);
   18070                                 }
   18071                                 ios.width(25);
   18072                                 internal(ios);
   18073                                 {
   18074                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18075                                     std::string ex(str, iter.base());
   18076                                     assert(ex == "+********1_234_567_89_0;1");
   18077                                     assert(ios.width() == 0);
   18078                                 }
   18079                             }
   18080                         }
   18081                         showpoint(ios);
   18082                         {
   18083                             ios.imbue(lc);
   18084                             {
   18085                                 ios.width(0);
   18086                                 {
   18087                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18088                                     std::string ex(str, iter.base());
   18089                                     assert(ex == "+1234567890.1");
   18090                                     assert(ios.width() == 0);
   18091                                 }
   18092                                 ios.width(25);
   18093                                 left(ios);
   18094                                 {
   18095                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18096                                     std::string ex(str, iter.base());
   18097                                     assert(ex == "+1234567890.1************");
   18098                                     assert(ios.width() == 0);
   18099                                 }
   18100                                 ios.width(25);
   18101                                 right(ios);
   18102                                 {
   18103                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18104                                     std::string ex(str, iter.base());
   18105                                     assert(ex == "************+1234567890.1");
   18106                                     assert(ios.width() == 0);
   18107                                 }
   18108                                 ios.width(25);
   18109                                 internal(ios);
   18110                                 {
   18111                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18112                                     std::string ex(str, iter.base());
   18113                                     assert(ex == "+************1234567890.1");
   18114                                     assert(ios.width() == 0);
   18115                                 }
   18116                             }
   18117                             ios.imbue(lg);
   18118                             {
   18119                                 ios.width(0);
   18120                                 {
   18121                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18122                                     std::string ex(str, iter.base());
   18123                                     assert(ex == "+1_234_567_89_0;1");
   18124                                     assert(ios.width() == 0);
   18125                                 }
   18126                                 ios.width(25);
   18127                                 left(ios);
   18128                                 {
   18129                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18130                                     std::string ex(str, iter.base());
   18131                                     assert(ex == "+1_234_567_89_0;1********");
   18132                                     assert(ios.width() == 0);
   18133                                 }
   18134                                 ios.width(25);
   18135                                 right(ios);
   18136                                 {
   18137                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18138                                     std::string ex(str, iter.base());
   18139                                     assert(ex == "********+1_234_567_89_0;1");
   18140                                     assert(ios.width() == 0);
   18141                                 }
   18142                                 ios.width(25);
   18143                                 internal(ios);
   18144                                 {
   18145                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18146                                     std::string ex(str, iter.base());
   18147                                     assert(ex == "+********1_234_567_89_0;1");
   18148                                     assert(ios.width() == 0);
   18149                                 }
   18150                             }
   18151                         }
   18152                     }
   18153                 }
   18154                 uppercase(ios);
   18155                 {
   18156                     noshowpos(ios);
   18157                     {
   18158                         noshowpoint(ios);
   18159                         {
   18160                             ios.imbue(lc);
   18161                             {
   18162                                 ios.width(0);
   18163                                 {
   18164                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18165                                     std::string ex(str, iter.base());
   18166                                     assert(ex == "1234567890.1");
   18167                                     assert(ios.width() == 0);
   18168                                 }
   18169                                 ios.width(25);
   18170                                 left(ios);
   18171                                 {
   18172                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18173                                     std::string ex(str, iter.base());
   18174                                     assert(ex == "1234567890.1*************");
   18175                                     assert(ios.width() == 0);
   18176                                 }
   18177                                 ios.width(25);
   18178                                 right(ios);
   18179                                 {
   18180                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18181                                     std::string ex(str, iter.base());
   18182                                     assert(ex == "*************1234567890.1");
   18183                                     assert(ios.width() == 0);
   18184                                 }
   18185                                 ios.width(25);
   18186                                 internal(ios);
   18187                                 {
   18188                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18189                                     std::string ex(str, iter.base());
   18190                                     assert(ex == "*************1234567890.1");
   18191                                     assert(ios.width() == 0);
   18192                                 }
   18193                             }
   18194                             ios.imbue(lg);
   18195                             {
   18196                                 ios.width(0);
   18197                                 {
   18198                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18199                                     std::string ex(str, iter.base());
   18200                                     assert(ex == "1_234_567_89_0;1");
   18201                                     assert(ios.width() == 0);
   18202                                 }
   18203                                 ios.width(25);
   18204                                 left(ios);
   18205                                 {
   18206                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18207                                     std::string ex(str, iter.base());
   18208                                     assert(ex == "1_234_567_89_0;1*********");
   18209                                     assert(ios.width() == 0);
   18210                                 }
   18211                                 ios.width(25);
   18212                                 right(ios);
   18213                                 {
   18214                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18215                                     std::string ex(str, iter.base());
   18216                                     assert(ex == "*********1_234_567_89_0;1");
   18217                                     assert(ios.width() == 0);
   18218                                 }
   18219                                 ios.width(25);
   18220                                 internal(ios);
   18221                                 {
   18222                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18223                                     std::string ex(str, iter.base());
   18224                                     assert(ex == "*********1_234_567_89_0;1");
   18225                                     assert(ios.width() == 0);
   18226                                 }
   18227                             }
   18228                         }
   18229                         showpoint(ios);
   18230                         {
   18231                             ios.imbue(lc);
   18232                             {
   18233                                 ios.width(0);
   18234                                 {
   18235                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18236                                     std::string ex(str, iter.base());
   18237                                     assert(ex == "1234567890.1");
   18238                                     assert(ios.width() == 0);
   18239                                 }
   18240                                 ios.width(25);
   18241                                 left(ios);
   18242                                 {
   18243                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18244                                     std::string ex(str, iter.base());
   18245                                     assert(ex == "1234567890.1*************");
   18246                                     assert(ios.width() == 0);
   18247                                 }
   18248                                 ios.width(25);
   18249                                 right(ios);
   18250                                 {
   18251                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18252                                     std::string ex(str, iter.base());
   18253                                     assert(ex == "*************1234567890.1");
   18254                                     assert(ios.width() == 0);
   18255                                 }
   18256                                 ios.width(25);
   18257                                 internal(ios);
   18258                                 {
   18259                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18260                                     std::string ex(str, iter.base());
   18261                                     assert(ex == "*************1234567890.1");
   18262                                     assert(ios.width() == 0);
   18263                                 }
   18264                             }
   18265                             ios.imbue(lg);
   18266                             {
   18267                                 ios.width(0);
   18268                                 {
   18269                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18270                                     std::string ex(str, iter.base());
   18271                                     assert(ex == "1_234_567_89_0;1");
   18272                                     assert(ios.width() == 0);
   18273                                 }
   18274                                 ios.width(25);
   18275                                 left(ios);
   18276                                 {
   18277                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18278                                     std::string ex(str, iter.base());
   18279                                     assert(ex == "1_234_567_89_0;1*********");
   18280                                     assert(ios.width() == 0);
   18281                                 }
   18282                                 ios.width(25);
   18283                                 right(ios);
   18284                                 {
   18285                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18286                                     std::string ex(str, iter.base());
   18287                                     assert(ex == "*********1_234_567_89_0;1");
   18288                                     assert(ios.width() == 0);
   18289                                 }
   18290                                 ios.width(25);
   18291                                 internal(ios);
   18292                                 {
   18293                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18294                                     std::string ex(str, iter.base());
   18295                                     assert(ex == "*********1_234_567_89_0;1");
   18296                                     assert(ios.width() == 0);
   18297                                 }
   18298                             }
   18299                         }
   18300                     }
   18301                     showpos(ios);
   18302                     {
   18303                         noshowpoint(ios);
   18304                         {
   18305                             ios.imbue(lc);
   18306                             {
   18307                                 ios.width(0);
   18308                                 {
   18309                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18310                                     std::string ex(str, iter.base());
   18311                                     assert(ex == "+1234567890.1");
   18312                                     assert(ios.width() == 0);
   18313                                 }
   18314                                 ios.width(25);
   18315                                 left(ios);
   18316                                 {
   18317                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18318                                     std::string ex(str, iter.base());
   18319                                     assert(ex == "+1234567890.1************");
   18320                                     assert(ios.width() == 0);
   18321                                 }
   18322                                 ios.width(25);
   18323                                 right(ios);
   18324                                 {
   18325                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18326                                     std::string ex(str, iter.base());
   18327                                     assert(ex == "************+1234567890.1");
   18328                                     assert(ios.width() == 0);
   18329                                 }
   18330                                 ios.width(25);
   18331                                 internal(ios);
   18332                                 {
   18333                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18334                                     std::string ex(str, iter.base());
   18335                                     assert(ex == "+************1234567890.1");
   18336                                     assert(ios.width() == 0);
   18337                                 }
   18338                             }
   18339                             ios.imbue(lg);
   18340                             {
   18341                                 ios.width(0);
   18342                                 {
   18343                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18344                                     std::string ex(str, iter.base());
   18345                                     assert(ex == "+1_234_567_89_0;1");
   18346                                     assert(ios.width() == 0);
   18347                                 }
   18348                                 ios.width(25);
   18349                                 left(ios);
   18350                                 {
   18351                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18352                                     std::string ex(str, iter.base());
   18353                                     assert(ex == "+1_234_567_89_0;1********");
   18354                                     assert(ios.width() == 0);
   18355                                 }
   18356                                 ios.width(25);
   18357                                 right(ios);
   18358                                 {
   18359                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18360                                     std::string ex(str, iter.base());
   18361                                     assert(ex == "********+1_234_567_89_0;1");
   18362                                     assert(ios.width() == 0);
   18363                                 }
   18364                                 ios.width(25);
   18365                                 internal(ios);
   18366                                 {
   18367                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18368                                     std::string ex(str, iter.base());
   18369                                     assert(ex == "+********1_234_567_89_0;1");
   18370                                     assert(ios.width() == 0);
   18371                                 }
   18372                             }
   18373                         }
   18374                         showpoint(ios);
   18375                         {
   18376                             ios.imbue(lc);
   18377                             {
   18378                                 ios.width(0);
   18379                                 {
   18380                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18381                                     std::string ex(str, iter.base());
   18382                                     assert(ex == "+1234567890.1");
   18383                                     assert(ios.width() == 0);
   18384                                 }
   18385                                 ios.width(25);
   18386                                 left(ios);
   18387                                 {
   18388                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18389                                     std::string ex(str, iter.base());
   18390                                     assert(ex == "+1234567890.1************");
   18391                                     assert(ios.width() == 0);
   18392                                 }
   18393                                 ios.width(25);
   18394                                 right(ios);
   18395                                 {
   18396                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18397                                     std::string ex(str, iter.base());
   18398                                     assert(ex == "************+1234567890.1");
   18399                                     assert(ios.width() == 0);
   18400                                 }
   18401                                 ios.width(25);
   18402                                 internal(ios);
   18403                                 {
   18404                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18405                                     std::string ex(str, iter.base());
   18406                                     assert(ex == "+************1234567890.1");
   18407                                     assert(ios.width() == 0);
   18408                                 }
   18409                             }
   18410                             ios.imbue(lg);
   18411                             {
   18412                                 ios.width(0);
   18413                                 {
   18414                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18415                                     std::string ex(str, iter.base());
   18416                                     assert(ex == "+1_234_567_89_0;1");
   18417                                     assert(ios.width() == 0);
   18418                                 }
   18419                                 ios.width(25);
   18420                                 left(ios);
   18421                                 {
   18422                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18423                                     std::string ex(str, iter.base());
   18424                                     assert(ex == "+1_234_567_89_0;1********");
   18425                                     assert(ios.width() == 0);
   18426                                 }
   18427                                 ios.width(25);
   18428                                 right(ios);
   18429                                 {
   18430                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18431                                     std::string ex(str, iter.base());
   18432                                     assert(ex == "********+1_234_567_89_0;1");
   18433                                     assert(ios.width() == 0);
   18434                                 }
   18435                                 ios.width(25);
   18436                                 internal(ios);
   18437                                 {
   18438                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18439                                     std::string ex(str, iter.base());
   18440                                     assert(ex == "+********1_234_567_89_0;1");
   18441                                     assert(ios.width() == 0);
   18442                                 }
   18443                             }
   18444                         }
   18445                     }
   18446                 }
   18447             }
   18448             ios.precision(6);
   18449             {
   18450                 nouppercase(ios);
   18451                 {
   18452                     noshowpos(ios);
   18453                     {
   18454                         noshowpoint(ios);
   18455                         {
   18456                             ios.imbue(lc);
   18457                             {
   18458                                 ios.width(0);
   18459                                 {
   18460                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18461                                     std::string ex(str, iter.base());
   18462                                     assert(ex == "1234567890.125000");
   18463                                     assert(ios.width() == 0);
   18464                                 }
   18465                                 ios.width(25);
   18466                                 left(ios);
   18467                                 {
   18468                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18469                                     std::string ex(str, iter.base());
   18470                                     assert(ex == "1234567890.125000********");
   18471                                     assert(ios.width() == 0);
   18472                                 }
   18473                                 ios.width(25);
   18474                                 right(ios);
   18475                                 {
   18476                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18477                                     std::string ex(str, iter.base());
   18478                                     assert(ex == "********1234567890.125000");
   18479                                     assert(ios.width() == 0);
   18480                                 }
   18481                                 ios.width(25);
   18482                                 internal(ios);
   18483                                 {
   18484                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18485                                     std::string ex(str, iter.base());
   18486                                     assert(ex == "********1234567890.125000");
   18487                                     assert(ios.width() == 0);
   18488                                 }
   18489                             }
   18490                             ios.imbue(lg);
   18491                             {
   18492                                 ios.width(0);
   18493                                 {
   18494                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18495                                     std::string ex(str, iter.base());
   18496                                     assert(ex == "1_234_567_89_0;125000");
   18497                                     assert(ios.width() == 0);
   18498                                 }
   18499                                 ios.width(25);
   18500                                 left(ios);
   18501                                 {
   18502                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18503                                     std::string ex(str, iter.base());
   18504                                     assert(ex == "1_234_567_89_0;125000****");
   18505                                     assert(ios.width() == 0);
   18506                                 }
   18507                                 ios.width(25);
   18508                                 right(ios);
   18509                                 {
   18510                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18511                                     std::string ex(str, iter.base());
   18512                                     assert(ex == "****1_234_567_89_0;125000");
   18513                                     assert(ios.width() == 0);
   18514                                 }
   18515                                 ios.width(25);
   18516                                 internal(ios);
   18517                                 {
   18518                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18519                                     std::string ex(str, iter.base());
   18520                                     assert(ex == "****1_234_567_89_0;125000");
   18521                                     assert(ios.width() == 0);
   18522                                 }
   18523                             }
   18524                         }
   18525                         showpoint(ios);
   18526                         {
   18527                             ios.imbue(lc);
   18528                             {
   18529                                 ios.width(0);
   18530                                 {
   18531                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18532                                     std::string ex(str, iter.base());
   18533                                     assert(ex == "1234567890.125000");
   18534                                     assert(ios.width() == 0);
   18535                                 }
   18536                                 ios.width(25);
   18537                                 left(ios);
   18538                                 {
   18539                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18540                                     std::string ex(str, iter.base());
   18541                                     assert(ex == "1234567890.125000********");
   18542                                     assert(ios.width() == 0);
   18543                                 }
   18544                                 ios.width(25);
   18545                                 right(ios);
   18546                                 {
   18547                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18548                                     std::string ex(str, iter.base());
   18549                                     assert(ex == "********1234567890.125000");
   18550                                     assert(ios.width() == 0);
   18551                                 }
   18552                                 ios.width(25);
   18553                                 internal(ios);
   18554                                 {
   18555                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18556                                     std::string ex(str, iter.base());
   18557                                     assert(ex == "********1234567890.125000");
   18558                                     assert(ios.width() == 0);
   18559                                 }
   18560                             }
   18561                             ios.imbue(lg);
   18562                             {
   18563                                 ios.width(0);
   18564                                 {
   18565                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18566                                     std::string ex(str, iter.base());
   18567                                     assert(ex == "1_234_567_89_0;125000");
   18568                                     assert(ios.width() == 0);
   18569                                 }
   18570                                 ios.width(25);
   18571                                 left(ios);
   18572                                 {
   18573                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18574                                     std::string ex(str, iter.base());
   18575                                     assert(ex == "1_234_567_89_0;125000****");
   18576                                     assert(ios.width() == 0);
   18577                                 }
   18578                                 ios.width(25);
   18579                                 right(ios);
   18580                                 {
   18581                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18582                                     std::string ex(str, iter.base());
   18583                                     assert(ex == "****1_234_567_89_0;125000");
   18584                                     assert(ios.width() == 0);
   18585                                 }
   18586                                 ios.width(25);
   18587                                 internal(ios);
   18588                                 {
   18589                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18590                                     std::string ex(str, iter.base());
   18591                                     assert(ex == "****1_234_567_89_0;125000");
   18592                                     assert(ios.width() == 0);
   18593                                 }
   18594                             }
   18595                         }
   18596                     }
   18597                     showpos(ios);
   18598                     {
   18599                         noshowpoint(ios);
   18600                         {
   18601                             ios.imbue(lc);
   18602                             {
   18603                                 ios.width(0);
   18604                                 {
   18605                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18606                                     std::string ex(str, iter.base());
   18607                                     assert(ex == "+1234567890.125000");
   18608                                     assert(ios.width() == 0);
   18609                                 }
   18610                                 ios.width(25);
   18611                                 left(ios);
   18612                                 {
   18613                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18614                                     std::string ex(str, iter.base());
   18615                                     assert(ex == "+1234567890.125000*******");
   18616                                     assert(ios.width() == 0);
   18617                                 }
   18618                                 ios.width(25);
   18619                                 right(ios);
   18620                                 {
   18621                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18622                                     std::string ex(str, iter.base());
   18623                                     assert(ex == "*******+1234567890.125000");
   18624                                     assert(ios.width() == 0);
   18625                                 }
   18626                                 ios.width(25);
   18627                                 internal(ios);
   18628                                 {
   18629                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18630                                     std::string ex(str, iter.base());
   18631                                     assert(ex == "+*******1234567890.125000");
   18632                                     assert(ios.width() == 0);
   18633                                 }
   18634                             }
   18635                             ios.imbue(lg);
   18636                             {
   18637                                 ios.width(0);
   18638                                 {
   18639                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18640                                     std::string ex(str, iter.base());
   18641                                     assert(ex == "+1_234_567_89_0;125000");
   18642                                     assert(ios.width() == 0);
   18643                                 }
   18644                                 ios.width(25);
   18645                                 left(ios);
   18646                                 {
   18647                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18648                                     std::string ex(str, iter.base());
   18649                                     assert(ex == "+1_234_567_89_0;125000***");
   18650                                     assert(ios.width() == 0);
   18651                                 }
   18652                                 ios.width(25);
   18653                                 right(ios);
   18654                                 {
   18655                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18656                                     std::string ex(str, iter.base());
   18657                                     assert(ex == "***+1_234_567_89_0;125000");
   18658                                     assert(ios.width() == 0);
   18659                                 }
   18660                                 ios.width(25);
   18661                                 internal(ios);
   18662                                 {
   18663                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18664                                     std::string ex(str, iter.base());
   18665                                     assert(ex == "+***1_234_567_89_0;125000");
   18666                                     assert(ios.width() == 0);
   18667                                 }
   18668                             }
   18669                         }
   18670                         showpoint(ios);
   18671                         {
   18672                             ios.imbue(lc);
   18673                             {
   18674                                 ios.width(0);
   18675                                 {
   18676                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18677                                     std::string ex(str, iter.base());
   18678                                     assert(ex == "+1234567890.125000");
   18679                                     assert(ios.width() == 0);
   18680                                 }
   18681                                 ios.width(25);
   18682                                 left(ios);
   18683                                 {
   18684                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18685                                     std::string ex(str, iter.base());
   18686                                     assert(ex == "+1234567890.125000*******");
   18687                                     assert(ios.width() == 0);
   18688                                 }
   18689                                 ios.width(25);
   18690                                 right(ios);
   18691                                 {
   18692                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18693                                     std::string ex(str, iter.base());
   18694                                     assert(ex == "*******+1234567890.125000");
   18695                                     assert(ios.width() == 0);
   18696                                 }
   18697                                 ios.width(25);
   18698                                 internal(ios);
   18699                                 {
   18700                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18701                                     std::string ex(str, iter.base());
   18702                                     assert(ex == "+*******1234567890.125000");
   18703                                     assert(ios.width() == 0);
   18704                                 }
   18705                             }
   18706                             ios.imbue(lg);
   18707                             {
   18708                                 ios.width(0);
   18709                                 {
   18710                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18711                                     std::string ex(str, iter.base());
   18712                                     assert(ex == "+1_234_567_89_0;125000");
   18713                                     assert(ios.width() == 0);
   18714                                 }
   18715                                 ios.width(25);
   18716                                 left(ios);
   18717                                 {
   18718                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18719                                     std::string ex(str, iter.base());
   18720                                     assert(ex == "+1_234_567_89_0;125000***");
   18721                                     assert(ios.width() == 0);
   18722                                 }
   18723                                 ios.width(25);
   18724                                 right(ios);
   18725                                 {
   18726                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18727                                     std::string ex(str, iter.base());
   18728                                     assert(ex == "***+1_234_567_89_0;125000");
   18729                                     assert(ios.width() == 0);
   18730                                 }
   18731                                 ios.width(25);
   18732                                 internal(ios);
   18733                                 {
   18734                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18735                                     std::string ex(str, iter.base());
   18736                                     assert(ex == "+***1_234_567_89_0;125000");
   18737                                     assert(ios.width() == 0);
   18738                                 }
   18739                             }
   18740                         }
   18741                     }
   18742                 }
   18743                 uppercase(ios);
   18744                 {
   18745                     noshowpos(ios);
   18746                     {
   18747                         noshowpoint(ios);
   18748                         {
   18749                             ios.imbue(lc);
   18750                             {
   18751                                 ios.width(0);
   18752                                 {
   18753                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18754                                     std::string ex(str, iter.base());
   18755                                     assert(ex == "1234567890.125000");
   18756                                     assert(ios.width() == 0);
   18757                                 }
   18758                                 ios.width(25);
   18759                                 left(ios);
   18760                                 {
   18761                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18762                                     std::string ex(str, iter.base());
   18763                                     assert(ex == "1234567890.125000********");
   18764                                     assert(ios.width() == 0);
   18765                                 }
   18766                                 ios.width(25);
   18767                                 right(ios);
   18768                                 {
   18769                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18770                                     std::string ex(str, iter.base());
   18771                                     assert(ex == "********1234567890.125000");
   18772                                     assert(ios.width() == 0);
   18773                                 }
   18774                                 ios.width(25);
   18775                                 internal(ios);
   18776                                 {
   18777                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18778                                     std::string ex(str, iter.base());
   18779                                     assert(ex == "********1234567890.125000");
   18780                                     assert(ios.width() == 0);
   18781                                 }
   18782                             }
   18783                             ios.imbue(lg);
   18784                             {
   18785                                 ios.width(0);
   18786                                 {
   18787                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18788                                     std::string ex(str, iter.base());
   18789                                     assert(ex == "1_234_567_89_0;125000");
   18790                                     assert(ios.width() == 0);
   18791                                 }
   18792                                 ios.width(25);
   18793                                 left(ios);
   18794                                 {
   18795                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18796                                     std::string ex(str, iter.base());
   18797                                     assert(ex == "1_234_567_89_0;125000****");
   18798                                     assert(ios.width() == 0);
   18799                                 }
   18800                                 ios.width(25);
   18801                                 right(ios);
   18802                                 {
   18803                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18804                                     std::string ex(str, iter.base());
   18805                                     assert(ex == "****1_234_567_89_0;125000");
   18806                                     assert(ios.width() == 0);
   18807                                 }
   18808                                 ios.width(25);
   18809                                 internal(ios);
   18810                                 {
   18811                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18812                                     std::string ex(str, iter.base());
   18813                                     assert(ex == "****1_234_567_89_0;125000");
   18814                                     assert(ios.width() == 0);
   18815                                 }
   18816                             }
   18817                         }
   18818                         showpoint(ios);
   18819                         {
   18820                             ios.imbue(lc);
   18821                             {
   18822                                 ios.width(0);
   18823                                 {
   18824                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18825                                     std::string ex(str, iter.base());
   18826                                     assert(ex == "1234567890.125000");
   18827                                     assert(ios.width() == 0);
   18828                                 }
   18829                                 ios.width(25);
   18830                                 left(ios);
   18831                                 {
   18832                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18833                                     std::string ex(str, iter.base());
   18834                                     assert(ex == "1234567890.125000********");
   18835                                     assert(ios.width() == 0);
   18836                                 }
   18837                                 ios.width(25);
   18838                                 right(ios);
   18839                                 {
   18840                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18841                                     std::string ex(str, iter.base());
   18842                                     assert(ex == "********1234567890.125000");
   18843                                     assert(ios.width() == 0);
   18844                                 }
   18845                                 ios.width(25);
   18846                                 internal(ios);
   18847                                 {
   18848                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18849                                     std::string ex(str, iter.base());
   18850                                     assert(ex == "********1234567890.125000");
   18851                                     assert(ios.width() == 0);
   18852                                 }
   18853                             }
   18854                             ios.imbue(lg);
   18855                             {
   18856                                 ios.width(0);
   18857                                 {
   18858                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18859                                     std::string ex(str, iter.base());
   18860                                     assert(ex == "1_234_567_89_0;125000");
   18861                                     assert(ios.width() == 0);
   18862                                 }
   18863                                 ios.width(25);
   18864                                 left(ios);
   18865                                 {
   18866                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18867                                     std::string ex(str, iter.base());
   18868                                     assert(ex == "1_234_567_89_0;125000****");
   18869                                     assert(ios.width() == 0);
   18870                                 }
   18871                                 ios.width(25);
   18872                                 right(ios);
   18873                                 {
   18874                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18875                                     std::string ex(str, iter.base());
   18876                                     assert(ex == "****1_234_567_89_0;125000");
   18877                                     assert(ios.width() == 0);
   18878                                 }
   18879                                 ios.width(25);
   18880                                 internal(ios);
   18881                                 {
   18882                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18883                                     std::string ex(str, iter.base());
   18884                                     assert(ex == "****1_234_567_89_0;125000");
   18885                                     assert(ios.width() == 0);
   18886                                 }
   18887                             }
   18888                         }
   18889                     }
   18890                     showpos(ios);
   18891                     {
   18892                         noshowpoint(ios);
   18893                         {
   18894                             ios.imbue(lc);
   18895                             {
   18896                                 ios.width(0);
   18897                                 {
   18898                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18899                                     std::string ex(str, iter.base());
   18900                                     assert(ex == "+1234567890.125000");
   18901                                     assert(ios.width() == 0);
   18902                                 }
   18903                                 ios.width(25);
   18904                                 left(ios);
   18905                                 {
   18906                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18907                                     std::string ex(str, iter.base());
   18908                                     assert(ex == "+1234567890.125000*******");
   18909                                     assert(ios.width() == 0);
   18910                                 }
   18911                                 ios.width(25);
   18912                                 right(ios);
   18913                                 {
   18914                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18915                                     std::string ex(str, iter.base());
   18916                                     assert(ex == "*******+1234567890.125000");
   18917                                     assert(ios.width() == 0);
   18918                                 }
   18919                                 ios.width(25);
   18920                                 internal(ios);
   18921                                 {
   18922                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18923                                     std::string ex(str, iter.base());
   18924                                     assert(ex == "+*******1234567890.125000");
   18925                                     assert(ios.width() == 0);
   18926                                 }
   18927                             }
   18928                             ios.imbue(lg);
   18929                             {
   18930                                 ios.width(0);
   18931                                 {
   18932                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18933                                     std::string ex(str, iter.base());
   18934                                     assert(ex == "+1_234_567_89_0;125000");
   18935                                     assert(ios.width() == 0);
   18936                                 }
   18937                                 ios.width(25);
   18938                                 left(ios);
   18939                                 {
   18940                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18941                                     std::string ex(str, iter.base());
   18942                                     assert(ex == "+1_234_567_89_0;125000***");
   18943                                     assert(ios.width() == 0);
   18944                                 }
   18945                                 ios.width(25);
   18946                                 right(ios);
   18947                                 {
   18948                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18949                                     std::string ex(str, iter.base());
   18950                                     assert(ex == "***+1_234_567_89_0;125000");
   18951                                     assert(ios.width() == 0);
   18952                                 }
   18953                                 ios.width(25);
   18954                                 internal(ios);
   18955                                 {
   18956                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18957                                     std::string ex(str, iter.base());
   18958                                     assert(ex == "+***1_234_567_89_0;125000");
   18959                                     assert(ios.width() == 0);
   18960                                 }
   18961                             }
   18962                         }
   18963                         showpoint(ios);
   18964                         {
   18965                             ios.imbue(lc);
   18966                             {
   18967                                 ios.width(0);
   18968                                 {
   18969                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18970                                     std::string ex(str, iter.base());
   18971                                     assert(ex == "+1234567890.125000");
   18972                                     assert(ios.width() == 0);
   18973                                 }
   18974                                 ios.width(25);
   18975                                 left(ios);
   18976                                 {
   18977                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18978                                     std::string ex(str, iter.base());
   18979                                     assert(ex == "+1234567890.125000*******");
   18980                                     assert(ios.width() == 0);
   18981                                 }
   18982                                 ios.width(25);
   18983                                 right(ios);
   18984                                 {
   18985                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18986                                     std::string ex(str, iter.base());
   18987                                     assert(ex == "*******+1234567890.125000");
   18988                                     assert(ios.width() == 0);
   18989                                 }
   18990                                 ios.width(25);
   18991                                 internal(ios);
   18992                                 {
   18993                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18994                                     std::string ex(str, iter.base());
   18995                                     assert(ex == "+*******1234567890.125000");
   18996                                     assert(ios.width() == 0);
   18997                                 }
   18998                             }
   18999                             ios.imbue(lg);
   19000                             {
   19001                                 ios.width(0);
   19002                                 {
   19003                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19004                                     std::string ex(str, iter.base());
   19005                                     assert(ex == "+1_234_567_89_0;125000");
   19006                                     assert(ios.width() == 0);
   19007                                 }
   19008                                 ios.width(25);
   19009                                 left(ios);
   19010                                 {
   19011                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19012                                     std::string ex(str, iter.base());
   19013                                     assert(ex == "+1_234_567_89_0;125000***");
   19014                                     assert(ios.width() == 0);
   19015                                 }
   19016                                 ios.width(25);
   19017                                 right(ios);
   19018                                 {
   19019                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19020                                     std::string ex(str, iter.base());
   19021                                     assert(ex == "***+1_234_567_89_0;125000");
   19022                                     assert(ios.width() == 0);
   19023                                 }
   19024                                 ios.width(25);
   19025                                 internal(ios);
   19026                                 {
   19027                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19028                                     std::string ex(str, iter.base());
   19029                                     assert(ex == "+***1_234_567_89_0;125000");
   19030                                     assert(ios.width() == 0);
   19031                                 }
   19032                             }
   19033                         }
   19034                     }
   19035                 }
   19036             }
   19037             ios.precision(16);
   19038             {}
   19039             ios.precision(60);
   19040             {}
   19041         }
   19042     }
   19043 }
   19044 
   19045 void test9()
   19046 {
   19047     char str[200];
   19048     output_iterator<char*> iter;
   19049     std::locale lc = std::locale::classic();
   19050     std::locale lg(lc, new my_numpunct);
   19051     const my_facet f(1);
   19052     {
   19053         long double v = -0.;
   19054         std::ios ios(0);
   19055         scientific(ios);
   19056         // %e
   19057         {
   19058             ios.precision(0);
   19059             {
   19060                 nouppercase(ios);
   19061                 {
   19062                     noshowpos(ios);
   19063                     {
   19064                         noshowpoint(ios);
   19065                         {
   19066                             ios.imbue(lc);
   19067                             {
   19068                                 ios.width(0);
   19069                                 {
   19070                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19071                                     std::string ex(str, iter.base());
   19072                                     assert(ex == "-0e+00");
   19073                                     assert(ios.width() == 0);
   19074                                 }
   19075                                 ios.width(25);
   19076                                 left(ios);
   19077                                 {
   19078                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19079                                     std::string ex(str, iter.base());
   19080                                     assert(ex == "-0e+00*******************");
   19081                                     assert(ios.width() == 0);
   19082                                 }
   19083                                 ios.width(25);
   19084                                 right(ios);
   19085                                 {
   19086                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19087                                     std::string ex(str, iter.base());
   19088                                     assert(ex == "*******************-0e+00");
   19089                                     assert(ios.width() == 0);
   19090                                 }
   19091                                 ios.width(25);
   19092                                 internal(ios);
   19093                                 {
   19094                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19095                                     std::string ex(str, iter.base());
   19096                                     assert(ex == "-*******************0e+00");
   19097                                     assert(ios.width() == 0);
   19098                                 }
   19099                             }
   19100                             ios.imbue(lg);
   19101                             {
   19102                                 ios.width(0);
   19103                                 {
   19104                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19105                                     std::string ex(str, iter.base());
   19106                                     assert(ex == "-0e+00");
   19107                                     assert(ios.width() == 0);
   19108                                 }
   19109                                 ios.width(25);
   19110                                 left(ios);
   19111                                 {
   19112                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19113                                     std::string ex(str, iter.base());
   19114                                     assert(ex == "-0e+00*******************");
   19115                                     assert(ios.width() == 0);
   19116                                 }
   19117                                 ios.width(25);
   19118                                 right(ios);
   19119                                 {
   19120                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19121                                     std::string ex(str, iter.base());
   19122                                     assert(ex == "*******************-0e+00");
   19123                                     assert(ios.width() == 0);
   19124                                 }
   19125                                 ios.width(25);
   19126                                 internal(ios);
   19127                                 {
   19128                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19129                                     std::string ex(str, iter.base());
   19130                                     assert(ex == "-*******************0e+00");
   19131                                     assert(ios.width() == 0);
   19132                                 }
   19133                             }
   19134                         }
   19135                         showpoint(ios);
   19136                         {
   19137                             ios.imbue(lc);
   19138                             {
   19139                                 ios.width(0);
   19140                                 {
   19141                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19142                                     std::string ex(str, iter.base());
   19143                                     assert(ex == "-0.e+00");
   19144                                     assert(ios.width() == 0);
   19145                                 }
   19146                                 ios.width(25);
   19147                                 left(ios);
   19148                                 {
   19149                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19150                                     std::string ex(str, iter.base());
   19151                                     assert(ex == "-0.e+00******************");
   19152                                     assert(ios.width() == 0);
   19153                                 }
   19154                                 ios.width(25);
   19155                                 right(ios);
   19156                                 {
   19157                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19158                                     std::string ex(str, iter.base());
   19159                                     assert(ex == "******************-0.e+00");
   19160                                     assert(ios.width() == 0);
   19161                                 }
   19162                                 ios.width(25);
   19163                                 internal(ios);
   19164                                 {
   19165                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19166                                     std::string ex(str, iter.base());
   19167                                     assert(ex == "-******************0.e+00");
   19168                                     assert(ios.width() == 0);
   19169                                 }
   19170                             }
   19171                             ios.imbue(lg);
   19172                             {
   19173                                 ios.width(0);
   19174                                 {
   19175                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19176                                     std::string ex(str, iter.base());
   19177                                     assert(ex == "-0;e+00");
   19178                                     assert(ios.width() == 0);
   19179                                 }
   19180                                 ios.width(25);
   19181                                 left(ios);
   19182                                 {
   19183                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19184                                     std::string ex(str, iter.base());
   19185                                     assert(ex == "-0;e+00******************");
   19186                                     assert(ios.width() == 0);
   19187                                 }
   19188                                 ios.width(25);
   19189                                 right(ios);
   19190                                 {
   19191                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19192                                     std::string ex(str, iter.base());
   19193                                     assert(ex == "******************-0;e+00");
   19194                                     assert(ios.width() == 0);
   19195                                 }
   19196                                 ios.width(25);
   19197                                 internal(ios);
   19198                                 {
   19199                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19200                                     std::string ex(str, iter.base());
   19201                                     assert(ex == "-******************0;e+00");
   19202                                     assert(ios.width() == 0);
   19203                                 }
   19204                             }
   19205                         }
   19206                     }
   19207                     showpos(ios);
   19208                     {
   19209                         noshowpoint(ios);
   19210                         {
   19211                             ios.imbue(lc);
   19212                             {
   19213                                 ios.width(0);
   19214                                 {
   19215                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19216                                     std::string ex(str, iter.base());
   19217                                     assert(ex == "-0e+00");
   19218                                     assert(ios.width() == 0);
   19219                                 }
   19220                                 ios.width(25);
   19221                                 left(ios);
   19222                                 {
   19223                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19224                                     std::string ex(str, iter.base());
   19225                                     assert(ex == "-0e+00*******************");
   19226                                     assert(ios.width() == 0);
   19227                                 }
   19228                                 ios.width(25);
   19229                                 right(ios);
   19230                                 {
   19231                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19232                                     std::string ex(str, iter.base());
   19233                                     assert(ex == "*******************-0e+00");
   19234                                     assert(ios.width() == 0);
   19235                                 }
   19236                                 ios.width(25);
   19237                                 internal(ios);
   19238                                 {
   19239                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19240                                     std::string ex(str, iter.base());
   19241                                     assert(ex == "-*******************0e+00");
   19242                                     assert(ios.width() == 0);
   19243                                 }
   19244                             }
   19245                             ios.imbue(lg);
   19246                             {
   19247                                 ios.width(0);
   19248                                 {
   19249                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19250                                     std::string ex(str, iter.base());
   19251                                     assert(ex == "-0e+00");
   19252                                     assert(ios.width() == 0);
   19253                                 }
   19254                                 ios.width(25);
   19255                                 left(ios);
   19256                                 {
   19257                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19258                                     std::string ex(str, iter.base());
   19259                                     assert(ex == "-0e+00*******************");
   19260                                     assert(ios.width() == 0);
   19261                                 }
   19262                                 ios.width(25);
   19263                                 right(ios);
   19264                                 {
   19265                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19266                                     std::string ex(str, iter.base());
   19267                                     assert(ex == "*******************-0e+00");
   19268                                     assert(ios.width() == 0);
   19269                                 }
   19270                                 ios.width(25);
   19271                                 internal(ios);
   19272                                 {
   19273                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19274                                     std::string ex(str, iter.base());
   19275                                     assert(ex == "-*******************0e+00");
   19276                                     assert(ios.width() == 0);
   19277                                 }
   19278                             }
   19279                         }
   19280                         showpoint(ios);
   19281                         {
   19282                             ios.imbue(lc);
   19283                             {
   19284                                 ios.width(0);
   19285                                 {
   19286                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19287                                     std::string ex(str, iter.base());
   19288                                     assert(ex == "-0.e+00");
   19289                                     assert(ios.width() == 0);
   19290                                 }
   19291                                 ios.width(25);
   19292                                 left(ios);
   19293                                 {
   19294                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19295                                     std::string ex(str, iter.base());
   19296                                     assert(ex == "-0.e+00******************");
   19297                                     assert(ios.width() == 0);
   19298                                 }
   19299                                 ios.width(25);
   19300                                 right(ios);
   19301                                 {
   19302                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19303                                     std::string ex(str, iter.base());
   19304                                     assert(ex == "******************-0.e+00");
   19305                                     assert(ios.width() == 0);
   19306                                 }
   19307                                 ios.width(25);
   19308                                 internal(ios);
   19309                                 {
   19310                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19311                                     std::string ex(str, iter.base());
   19312                                     assert(ex == "-******************0.e+00");
   19313                                     assert(ios.width() == 0);
   19314                                 }
   19315                             }
   19316                             ios.imbue(lg);
   19317                             {
   19318                                 ios.width(0);
   19319                                 {
   19320                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19321                                     std::string ex(str, iter.base());
   19322                                     assert(ex == "-0;e+00");
   19323                                     assert(ios.width() == 0);
   19324                                 }
   19325                                 ios.width(25);
   19326                                 left(ios);
   19327                                 {
   19328                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19329                                     std::string ex(str, iter.base());
   19330                                     assert(ex == "-0;e+00******************");
   19331                                     assert(ios.width() == 0);
   19332                                 }
   19333                                 ios.width(25);
   19334                                 right(ios);
   19335                                 {
   19336                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19337                                     std::string ex(str, iter.base());
   19338                                     assert(ex == "******************-0;e+00");
   19339                                     assert(ios.width() == 0);
   19340                                 }
   19341                                 ios.width(25);
   19342                                 internal(ios);
   19343                                 {
   19344                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19345                                     std::string ex(str, iter.base());
   19346                                     assert(ex == "-******************0;e+00");
   19347                                     assert(ios.width() == 0);
   19348                                 }
   19349                             }
   19350                         }
   19351                     }
   19352                 }
   19353                 uppercase(ios);
   19354                 {
   19355                     noshowpos(ios);
   19356                     {
   19357                         noshowpoint(ios);
   19358                         {
   19359                             ios.imbue(lc);
   19360                             {
   19361                                 ios.width(0);
   19362                                 {
   19363                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19364                                     std::string ex(str, iter.base());
   19365                                     assert(ex == "-0E+00");
   19366                                     assert(ios.width() == 0);
   19367                                 }
   19368                                 ios.width(25);
   19369                                 left(ios);
   19370                                 {
   19371                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19372                                     std::string ex(str, iter.base());
   19373                                     assert(ex == "-0E+00*******************");
   19374                                     assert(ios.width() == 0);
   19375                                 }
   19376                                 ios.width(25);
   19377                                 right(ios);
   19378                                 {
   19379                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19380                                     std::string ex(str, iter.base());
   19381                                     assert(ex == "*******************-0E+00");
   19382                                     assert(ios.width() == 0);
   19383                                 }
   19384                                 ios.width(25);
   19385                                 internal(ios);
   19386                                 {
   19387                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19388                                     std::string ex(str, iter.base());
   19389                                     assert(ex == "-*******************0E+00");
   19390                                     assert(ios.width() == 0);
   19391                                 }
   19392                             }
   19393                             ios.imbue(lg);
   19394                             {
   19395                                 ios.width(0);
   19396                                 {
   19397                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19398                                     std::string ex(str, iter.base());
   19399                                     assert(ex == "-0E+00");
   19400                                     assert(ios.width() == 0);
   19401                                 }
   19402                                 ios.width(25);
   19403                                 left(ios);
   19404                                 {
   19405                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19406                                     std::string ex(str, iter.base());
   19407                                     assert(ex == "-0E+00*******************");
   19408                                     assert(ios.width() == 0);
   19409                                 }
   19410                                 ios.width(25);
   19411                                 right(ios);
   19412                                 {
   19413                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19414                                     std::string ex(str, iter.base());
   19415                                     assert(ex == "*******************-0E+00");
   19416                                     assert(ios.width() == 0);
   19417                                 }
   19418                                 ios.width(25);
   19419                                 internal(ios);
   19420                                 {
   19421                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19422                                     std::string ex(str, iter.base());
   19423                                     assert(ex == "-*******************0E+00");
   19424                                     assert(ios.width() == 0);
   19425                                 }
   19426                             }
   19427                         }
   19428                         showpoint(ios);
   19429                         {
   19430                             ios.imbue(lc);
   19431                             {
   19432                                 ios.width(0);
   19433                                 {
   19434                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19435                                     std::string ex(str, iter.base());
   19436                                     assert(ex == "-0.E+00");
   19437                                     assert(ios.width() == 0);
   19438                                 }
   19439                                 ios.width(25);
   19440                                 left(ios);
   19441                                 {
   19442                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19443                                     std::string ex(str, iter.base());
   19444                                     assert(ex == "-0.E+00******************");
   19445                                     assert(ios.width() == 0);
   19446                                 }
   19447                                 ios.width(25);
   19448                                 right(ios);
   19449                                 {
   19450                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19451                                     std::string ex(str, iter.base());
   19452                                     assert(ex == "******************-0.E+00");
   19453                                     assert(ios.width() == 0);
   19454                                 }
   19455                                 ios.width(25);
   19456                                 internal(ios);
   19457                                 {
   19458                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19459                                     std::string ex(str, iter.base());
   19460                                     assert(ex == "-******************0.E+00");
   19461                                     assert(ios.width() == 0);
   19462                                 }
   19463                             }
   19464                             ios.imbue(lg);
   19465                             {
   19466                                 ios.width(0);
   19467                                 {
   19468                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19469                                     std::string ex(str, iter.base());
   19470                                     assert(ex == "-0;E+00");
   19471                                     assert(ios.width() == 0);
   19472                                 }
   19473                                 ios.width(25);
   19474                                 left(ios);
   19475                                 {
   19476                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19477                                     std::string ex(str, iter.base());
   19478                                     assert(ex == "-0;E+00******************");
   19479                                     assert(ios.width() == 0);
   19480                                 }
   19481                                 ios.width(25);
   19482                                 right(ios);
   19483                                 {
   19484                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19485                                     std::string ex(str, iter.base());
   19486                                     assert(ex == "******************-0;E+00");
   19487                                     assert(ios.width() == 0);
   19488                                 }
   19489                                 ios.width(25);
   19490                                 internal(ios);
   19491                                 {
   19492                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19493                                     std::string ex(str, iter.base());
   19494                                     assert(ex == "-******************0;E+00");
   19495                                     assert(ios.width() == 0);
   19496                                 }
   19497                             }
   19498                         }
   19499                     }
   19500                     showpos(ios);
   19501                     {
   19502                         noshowpoint(ios);
   19503                         {
   19504                             ios.imbue(lc);
   19505                             {
   19506                                 ios.width(0);
   19507                                 {
   19508                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19509                                     std::string ex(str, iter.base());
   19510                                     assert(ex == "-0E+00");
   19511                                     assert(ios.width() == 0);
   19512                                 }
   19513                                 ios.width(25);
   19514                                 left(ios);
   19515                                 {
   19516                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19517                                     std::string ex(str, iter.base());
   19518                                     assert(ex == "-0E+00*******************");
   19519                                     assert(ios.width() == 0);
   19520                                 }
   19521                                 ios.width(25);
   19522                                 right(ios);
   19523                                 {
   19524                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19525                                     std::string ex(str, iter.base());
   19526                                     assert(ex == "*******************-0E+00");
   19527                                     assert(ios.width() == 0);
   19528                                 }
   19529                                 ios.width(25);
   19530                                 internal(ios);
   19531                                 {
   19532                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19533                                     std::string ex(str, iter.base());
   19534                                     assert(ex == "-*******************0E+00");
   19535                                     assert(ios.width() == 0);
   19536                                 }
   19537                             }
   19538                             ios.imbue(lg);
   19539                             {
   19540                                 ios.width(0);
   19541                                 {
   19542                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19543                                     std::string ex(str, iter.base());
   19544                                     assert(ex == "-0E+00");
   19545                                     assert(ios.width() == 0);
   19546                                 }
   19547                                 ios.width(25);
   19548                                 left(ios);
   19549                                 {
   19550                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19551                                     std::string ex(str, iter.base());
   19552                                     assert(ex == "-0E+00*******************");
   19553                                     assert(ios.width() == 0);
   19554                                 }
   19555                                 ios.width(25);
   19556                                 right(ios);
   19557                                 {
   19558                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19559                                     std::string ex(str, iter.base());
   19560                                     assert(ex == "*******************-0E+00");
   19561                                     assert(ios.width() == 0);
   19562                                 }
   19563                                 ios.width(25);
   19564                                 internal(ios);
   19565                                 {
   19566                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19567                                     std::string ex(str, iter.base());
   19568                                     assert(ex == "-*******************0E+00");
   19569                                     assert(ios.width() == 0);
   19570                                 }
   19571                             }
   19572                         }
   19573                         showpoint(ios);
   19574                         {
   19575                             ios.imbue(lc);
   19576                             {
   19577                                 ios.width(0);
   19578                                 {
   19579                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19580                                     std::string ex(str, iter.base());
   19581                                     assert(ex == "-0.E+00");
   19582                                     assert(ios.width() == 0);
   19583                                 }
   19584                                 ios.width(25);
   19585                                 left(ios);
   19586                                 {
   19587                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19588                                     std::string ex(str, iter.base());
   19589                                     assert(ex == "-0.E+00******************");
   19590                                     assert(ios.width() == 0);
   19591                                 }
   19592                                 ios.width(25);
   19593                                 right(ios);
   19594                                 {
   19595                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19596                                     std::string ex(str, iter.base());
   19597                                     assert(ex == "******************-0.E+00");
   19598                                     assert(ios.width() == 0);
   19599                                 }
   19600                                 ios.width(25);
   19601                                 internal(ios);
   19602                                 {
   19603                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19604                                     std::string ex(str, iter.base());
   19605                                     assert(ex == "-******************0.E+00");
   19606                                     assert(ios.width() == 0);
   19607                                 }
   19608                             }
   19609                             ios.imbue(lg);
   19610                             {
   19611                                 ios.width(0);
   19612                                 {
   19613                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19614                                     std::string ex(str, iter.base());
   19615                                     assert(ex == "-0;E+00");
   19616                                     assert(ios.width() == 0);
   19617                                 }
   19618                                 ios.width(25);
   19619                                 left(ios);
   19620                                 {
   19621                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19622                                     std::string ex(str, iter.base());
   19623                                     assert(ex == "-0;E+00******************");
   19624                                     assert(ios.width() == 0);
   19625                                 }
   19626                                 ios.width(25);
   19627                                 right(ios);
   19628                                 {
   19629                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19630                                     std::string ex(str, iter.base());
   19631                                     assert(ex == "******************-0;E+00");
   19632                                     assert(ios.width() == 0);
   19633                                 }
   19634                                 ios.width(25);
   19635                                 internal(ios);
   19636                                 {
   19637                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19638                                     std::string ex(str, iter.base());
   19639                                     assert(ex == "-******************0;E+00");
   19640                                     assert(ios.width() == 0);
   19641                                 }
   19642                             }
   19643                         }
   19644                     }
   19645                 }
   19646             }
   19647             ios.precision(1);
   19648             {
   19649                 nouppercase(ios);
   19650                 {
   19651                     noshowpos(ios);
   19652                     {
   19653                         noshowpoint(ios);
   19654                         {
   19655                             ios.imbue(lc);
   19656                             {
   19657                                 ios.width(0);
   19658                                 {
   19659                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19660                                     std::string ex(str, iter.base());
   19661                                     assert(ex == "-0.0e+00");
   19662                                     assert(ios.width() == 0);
   19663                                 }
   19664                                 ios.width(25);
   19665                                 left(ios);
   19666                                 {
   19667                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19668                                     std::string ex(str, iter.base());
   19669                                     assert(ex == "-0.0e+00*****************");
   19670                                     assert(ios.width() == 0);
   19671                                 }
   19672                                 ios.width(25);
   19673                                 right(ios);
   19674                                 {
   19675                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19676                                     std::string ex(str, iter.base());
   19677                                     assert(ex == "*****************-0.0e+00");
   19678                                     assert(ios.width() == 0);
   19679                                 }
   19680                                 ios.width(25);
   19681                                 internal(ios);
   19682                                 {
   19683                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19684                                     std::string ex(str, iter.base());
   19685                                     assert(ex == "-*****************0.0e+00");
   19686                                     assert(ios.width() == 0);
   19687                                 }
   19688                             }
   19689                             ios.imbue(lg);
   19690                             {
   19691                                 ios.width(0);
   19692                                 {
   19693                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19694                                     std::string ex(str, iter.base());
   19695                                     assert(ex == "-0;0e+00");
   19696                                     assert(ios.width() == 0);
   19697                                 }
   19698                                 ios.width(25);
   19699                                 left(ios);
   19700                                 {
   19701                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19702                                     std::string ex(str, iter.base());
   19703                                     assert(ex == "-0;0e+00*****************");
   19704                                     assert(ios.width() == 0);
   19705                                 }
   19706                                 ios.width(25);
   19707                                 right(ios);
   19708                                 {
   19709                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19710                                     std::string ex(str, iter.base());
   19711                                     assert(ex == "*****************-0;0e+00");
   19712                                     assert(ios.width() == 0);
   19713                                 }
   19714                                 ios.width(25);
   19715                                 internal(ios);
   19716                                 {
   19717                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19718                                     std::string ex(str, iter.base());
   19719                                     assert(ex == "-*****************0;0e+00");
   19720                                     assert(ios.width() == 0);
   19721                                 }
   19722                             }
   19723                         }
   19724                         showpoint(ios);
   19725                         {
   19726                             ios.imbue(lc);
   19727                             {
   19728                                 ios.width(0);
   19729                                 {
   19730                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19731                                     std::string ex(str, iter.base());
   19732                                     assert(ex == "-0.0e+00");
   19733                                     assert(ios.width() == 0);
   19734                                 }
   19735                                 ios.width(25);
   19736                                 left(ios);
   19737                                 {
   19738                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19739                                     std::string ex(str, iter.base());
   19740                                     assert(ex == "-0.0e+00*****************");
   19741                                     assert(ios.width() == 0);
   19742                                 }
   19743                                 ios.width(25);
   19744                                 right(ios);
   19745                                 {
   19746                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19747                                     std::string ex(str, iter.base());
   19748                                     assert(ex == "*****************-0.0e+00");
   19749                                     assert(ios.width() == 0);
   19750                                 }
   19751                                 ios.width(25);
   19752                                 internal(ios);
   19753                                 {
   19754                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19755                                     std::string ex(str, iter.base());
   19756                                     assert(ex == "-*****************0.0e+00");
   19757                                     assert(ios.width() == 0);
   19758                                 }
   19759                             }
   19760                             ios.imbue(lg);
   19761                             {
   19762                                 ios.width(0);
   19763                                 {
   19764                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19765                                     std::string ex(str, iter.base());
   19766                                     assert(ex == "-0;0e+00");
   19767                                     assert(ios.width() == 0);
   19768                                 }
   19769                                 ios.width(25);
   19770                                 left(ios);
   19771                                 {
   19772                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19773                                     std::string ex(str, iter.base());
   19774                                     assert(ex == "-0;0e+00*****************");
   19775                                     assert(ios.width() == 0);
   19776                                 }
   19777                                 ios.width(25);
   19778                                 right(ios);
   19779                                 {
   19780                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19781                                     std::string ex(str, iter.base());
   19782                                     assert(ex == "*****************-0;0e+00");
   19783                                     assert(ios.width() == 0);
   19784                                 }
   19785                                 ios.width(25);
   19786                                 internal(ios);
   19787                                 {
   19788                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19789                                     std::string ex(str, iter.base());
   19790                                     assert(ex == "-*****************0;0e+00");
   19791                                     assert(ios.width() == 0);
   19792                                 }
   19793                             }
   19794                         }
   19795                     }
   19796                     showpos(ios);
   19797                     {
   19798                         noshowpoint(ios);
   19799                         {
   19800                             ios.imbue(lc);
   19801                             {
   19802                                 ios.width(0);
   19803                                 {
   19804                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19805                                     std::string ex(str, iter.base());
   19806                                     assert(ex == "-0.0e+00");
   19807                                     assert(ios.width() == 0);
   19808                                 }
   19809                                 ios.width(25);
   19810                                 left(ios);
   19811                                 {
   19812                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19813                                     std::string ex(str, iter.base());
   19814                                     assert(ex == "-0.0e+00*****************");
   19815                                     assert(ios.width() == 0);
   19816                                 }
   19817                                 ios.width(25);
   19818                                 right(ios);
   19819                                 {
   19820                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19821                                     std::string ex(str, iter.base());
   19822                                     assert(ex == "*****************-0.0e+00");
   19823                                     assert(ios.width() == 0);
   19824                                 }
   19825                                 ios.width(25);
   19826                                 internal(ios);
   19827                                 {
   19828                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19829                                     std::string ex(str, iter.base());
   19830                                     assert(ex == "-*****************0.0e+00");
   19831                                     assert(ios.width() == 0);
   19832                                 }
   19833                             }
   19834                             ios.imbue(lg);
   19835                             {
   19836                                 ios.width(0);
   19837                                 {
   19838                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19839                                     std::string ex(str, iter.base());
   19840                                     assert(ex == "-0;0e+00");
   19841                                     assert(ios.width() == 0);
   19842                                 }
   19843                                 ios.width(25);
   19844                                 left(ios);
   19845                                 {
   19846                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19847                                     std::string ex(str, iter.base());
   19848                                     assert(ex == "-0;0e+00*****************");
   19849                                     assert(ios.width() == 0);
   19850                                 }
   19851                                 ios.width(25);
   19852                                 right(ios);
   19853                                 {
   19854                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19855                                     std::string ex(str, iter.base());
   19856                                     assert(ex == "*****************-0;0e+00");
   19857                                     assert(ios.width() == 0);
   19858                                 }
   19859                                 ios.width(25);
   19860                                 internal(ios);
   19861                                 {
   19862                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19863                                     std::string ex(str, iter.base());
   19864                                     assert(ex == "-*****************0;0e+00");
   19865                                     assert(ios.width() == 0);
   19866                                 }
   19867                             }
   19868                         }
   19869                         showpoint(ios);
   19870                         {
   19871                             ios.imbue(lc);
   19872                             {
   19873                                 ios.width(0);
   19874                                 {
   19875                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19876                                     std::string ex(str, iter.base());
   19877                                     assert(ex == "-0.0e+00");
   19878                                     assert(ios.width() == 0);
   19879                                 }
   19880                                 ios.width(25);
   19881                                 left(ios);
   19882                                 {
   19883                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19884                                     std::string ex(str, iter.base());
   19885                                     assert(ex == "-0.0e+00*****************");
   19886                                     assert(ios.width() == 0);
   19887                                 }
   19888                                 ios.width(25);
   19889                                 right(ios);
   19890                                 {
   19891                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19892                                     std::string ex(str, iter.base());
   19893                                     assert(ex == "*****************-0.0e+00");
   19894                                     assert(ios.width() == 0);
   19895                                 }
   19896                                 ios.width(25);
   19897                                 internal(ios);
   19898                                 {
   19899                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19900                                     std::string ex(str, iter.base());
   19901                                     assert(ex == "-*****************0.0e+00");
   19902                                     assert(ios.width() == 0);
   19903                                 }
   19904                             }
   19905                             ios.imbue(lg);
   19906                             {
   19907                                 ios.width(0);
   19908                                 {
   19909                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19910                                     std::string ex(str, iter.base());
   19911                                     assert(ex == "-0;0e+00");
   19912                                     assert(ios.width() == 0);
   19913                                 }
   19914                                 ios.width(25);
   19915                                 left(ios);
   19916                                 {
   19917                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19918                                     std::string ex(str, iter.base());
   19919                                     assert(ex == "-0;0e+00*****************");
   19920                                     assert(ios.width() == 0);
   19921                                 }
   19922                                 ios.width(25);
   19923                                 right(ios);
   19924                                 {
   19925                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19926                                     std::string ex(str, iter.base());
   19927                                     assert(ex == "*****************-0;0e+00");
   19928                                     assert(ios.width() == 0);
   19929                                 }
   19930                                 ios.width(25);
   19931                                 internal(ios);
   19932                                 {
   19933                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19934                                     std::string ex(str, iter.base());
   19935                                     assert(ex == "-*****************0;0e+00");
   19936                                     assert(ios.width() == 0);
   19937                                 }
   19938                             }
   19939                         }
   19940                     }
   19941                 }
   19942                 uppercase(ios);
   19943                 {
   19944                     noshowpos(ios);
   19945                     {
   19946                         noshowpoint(ios);
   19947                         {
   19948                             ios.imbue(lc);
   19949                             {
   19950                                 ios.width(0);
   19951                                 {
   19952                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19953                                     std::string ex(str, iter.base());
   19954                                     assert(ex == "-0.0E+00");
   19955                                     assert(ios.width() == 0);
   19956                                 }
   19957                                 ios.width(25);
   19958                                 left(ios);
   19959                                 {
   19960                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19961                                     std::string ex(str, iter.base());
   19962                                     assert(ex == "-0.0E+00*****************");
   19963                                     assert(ios.width() == 0);
   19964                                 }
   19965                                 ios.width(25);
   19966                                 right(ios);
   19967                                 {
   19968                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19969                                     std::string ex(str, iter.base());
   19970                                     assert(ex == "*****************-0.0E+00");
   19971                                     assert(ios.width() == 0);
   19972                                 }
   19973                                 ios.width(25);
   19974                                 internal(ios);
   19975                                 {
   19976                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19977                                     std::string ex(str, iter.base());
   19978                                     assert(ex == "-*****************0.0E+00");
   19979                                     assert(ios.width() == 0);
   19980                                 }
   19981                             }
   19982                             ios.imbue(lg);
   19983                             {
   19984                                 ios.width(0);
   19985                                 {
   19986                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19987                                     std::string ex(str, iter.base());
   19988                                     assert(ex == "-0;0E+00");
   19989                                     assert(ios.width() == 0);
   19990                                 }
   19991                                 ios.width(25);
   19992                                 left(ios);
   19993                                 {
   19994                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19995                                     std::string ex(str, iter.base());
   19996                                     assert(ex == "-0;0E+00*****************");
   19997                                     assert(ios.width() == 0);
   19998                                 }
   19999                                 ios.width(25);
   20000                                 right(ios);
   20001                                 {
   20002                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20003                                     std::string ex(str, iter.base());
   20004                                     assert(ex == "*****************-0;0E+00");
   20005                                     assert(ios.width() == 0);
   20006                                 }
   20007                                 ios.width(25);
   20008                                 internal(ios);
   20009                                 {
   20010                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20011                                     std::string ex(str, iter.base());
   20012                                     assert(ex == "-*****************0;0E+00");
   20013                                     assert(ios.width() == 0);
   20014                                 }
   20015                             }
   20016                         }
   20017                         showpoint(ios);
   20018                         {
   20019                             ios.imbue(lc);
   20020                             {
   20021                                 ios.width(0);
   20022                                 {
   20023                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20024                                     std::string ex(str, iter.base());
   20025                                     assert(ex == "-0.0E+00");
   20026                                     assert(ios.width() == 0);
   20027                                 }
   20028                                 ios.width(25);
   20029                                 left(ios);
   20030                                 {
   20031                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20032                                     std::string ex(str, iter.base());
   20033                                     assert(ex == "-0.0E+00*****************");
   20034                                     assert(ios.width() == 0);
   20035                                 }
   20036                                 ios.width(25);
   20037                                 right(ios);
   20038                                 {
   20039                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20040                                     std::string ex(str, iter.base());
   20041                                     assert(ex == "*****************-0.0E+00");
   20042                                     assert(ios.width() == 0);
   20043                                 }
   20044                                 ios.width(25);
   20045                                 internal(ios);
   20046                                 {
   20047                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20048                                     std::string ex(str, iter.base());
   20049                                     assert(ex == "-*****************0.0E+00");
   20050                                     assert(ios.width() == 0);
   20051                                 }
   20052                             }
   20053                             ios.imbue(lg);
   20054                             {
   20055                                 ios.width(0);
   20056                                 {
   20057                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20058                                     std::string ex(str, iter.base());
   20059                                     assert(ex == "-0;0E+00");
   20060                                     assert(ios.width() == 0);
   20061                                 }
   20062                                 ios.width(25);
   20063                                 left(ios);
   20064                                 {
   20065                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20066                                     std::string ex(str, iter.base());
   20067                                     assert(ex == "-0;0E+00*****************");
   20068                                     assert(ios.width() == 0);
   20069                                 }
   20070                                 ios.width(25);
   20071                                 right(ios);
   20072                                 {
   20073                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20074                                     std::string ex(str, iter.base());
   20075                                     assert(ex == "*****************-0;0E+00");
   20076                                     assert(ios.width() == 0);
   20077                                 }
   20078                                 ios.width(25);
   20079                                 internal(ios);
   20080                                 {
   20081                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20082                                     std::string ex(str, iter.base());
   20083                                     assert(ex == "-*****************0;0E+00");
   20084                                     assert(ios.width() == 0);
   20085                                 }
   20086                             }
   20087                         }
   20088                     }
   20089                     showpos(ios);
   20090                     {
   20091                         noshowpoint(ios);
   20092                         {
   20093                             ios.imbue(lc);
   20094                             {
   20095                                 ios.width(0);
   20096                                 {
   20097                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20098                                     std::string ex(str, iter.base());
   20099                                     assert(ex == "-0.0E+00");
   20100                                     assert(ios.width() == 0);
   20101                                 }
   20102                                 ios.width(25);
   20103                                 left(ios);
   20104                                 {
   20105                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20106                                     std::string ex(str, iter.base());
   20107                                     assert(ex == "-0.0E+00*****************");
   20108                                     assert(ios.width() == 0);
   20109                                 }
   20110                                 ios.width(25);
   20111                                 right(ios);
   20112                                 {
   20113                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20114                                     std::string ex(str, iter.base());
   20115                                     assert(ex == "*****************-0.0E+00");
   20116                                     assert(ios.width() == 0);
   20117                                 }
   20118                                 ios.width(25);
   20119                                 internal(ios);
   20120                                 {
   20121                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20122                                     std::string ex(str, iter.base());
   20123                                     assert(ex == "-*****************0.0E+00");
   20124                                     assert(ios.width() == 0);
   20125                                 }
   20126                             }
   20127                             ios.imbue(lg);
   20128                             {
   20129                                 ios.width(0);
   20130                                 {
   20131                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20132                                     std::string ex(str, iter.base());
   20133                                     assert(ex == "-0;0E+00");
   20134                                     assert(ios.width() == 0);
   20135                                 }
   20136                                 ios.width(25);
   20137                                 left(ios);
   20138                                 {
   20139                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20140                                     std::string ex(str, iter.base());
   20141                                     assert(ex == "-0;0E+00*****************");
   20142                                     assert(ios.width() == 0);
   20143                                 }
   20144                                 ios.width(25);
   20145                                 right(ios);
   20146                                 {
   20147                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20148                                     std::string ex(str, iter.base());
   20149                                     assert(ex == "*****************-0;0E+00");
   20150                                     assert(ios.width() == 0);
   20151                                 }
   20152                                 ios.width(25);
   20153                                 internal(ios);
   20154                                 {
   20155                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20156                                     std::string ex(str, iter.base());
   20157                                     assert(ex == "-*****************0;0E+00");
   20158                                     assert(ios.width() == 0);
   20159                                 }
   20160                             }
   20161                         }
   20162                         showpoint(ios);
   20163                         {
   20164                             ios.imbue(lc);
   20165                             {
   20166                                 ios.width(0);
   20167                                 {
   20168                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20169                                     std::string ex(str, iter.base());
   20170                                     assert(ex == "-0.0E+00");
   20171                                     assert(ios.width() == 0);
   20172                                 }
   20173                                 ios.width(25);
   20174                                 left(ios);
   20175                                 {
   20176                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20177                                     std::string ex(str, iter.base());
   20178                                     assert(ex == "-0.0E+00*****************");
   20179                                     assert(ios.width() == 0);
   20180                                 }
   20181                                 ios.width(25);
   20182                                 right(ios);
   20183                                 {
   20184                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20185                                     std::string ex(str, iter.base());
   20186                                     assert(ex == "*****************-0.0E+00");
   20187                                     assert(ios.width() == 0);
   20188                                 }
   20189                                 ios.width(25);
   20190                                 internal(ios);
   20191                                 {
   20192                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20193                                     std::string ex(str, iter.base());
   20194                                     assert(ex == "-*****************0.0E+00");
   20195                                     assert(ios.width() == 0);
   20196                                 }
   20197                             }
   20198                             ios.imbue(lg);
   20199                             {
   20200                                 ios.width(0);
   20201                                 {
   20202                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20203                                     std::string ex(str, iter.base());
   20204                                     assert(ex == "-0;0E+00");
   20205                                     assert(ios.width() == 0);
   20206                                 }
   20207                                 ios.width(25);
   20208                                 left(ios);
   20209                                 {
   20210                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20211                                     std::string ex(str, iter.base());
   20212                                     assert(ex == "-0;0E+00*****************");
   20213                                     assert(ios.width() == 0);
   20214                                 }
   20215                                 ios.width(25);
   20216                                 right(ios);
   20217                                 {
   20218                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20219                                     std::string ex(str, iter.base());
   20220                                     assert(ex == "*****************-0;0E+00");
   20221                                     assert(ios.width() == 0);
   20222                                 }
   20223                                 ios.width(25);
   20224                                 internal(ios);
   20225                                 {
   20226                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20227                                     std::string ex(str, iter.base());
   20228                                     assert(ex == "-*****************0;0E+00");
   20229                                     assert(ios.width() == 0);
   20230                                 }
   20231                             }
   20232                         }
   20233                     }
   20234                 }
   20235             }
   20236             ios.precision(6);
   20237             {
   20238                 nouppercase(ios);
   20239                 {
   20240                     noshowpos(ios);
   20241                     {
   20242                         noshowpoint(ios);
   20243                         {
   20244                             ios.imbue(lc);
   20245                             {
   20246                                 ios.width(0);
   20247                                 {
   20248                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20249                                     std::string ex(str, iter.base());
   20250                                     assert(ex == "-0.000000e+00");
   20251                                     assert(ios.width() == 0);
   20252                                 }
   20253                                 ios.width(25);
   20254                                 left(ios);
   20255                                 {
   20256                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20257                                     std::string ex(str, iter.base());
   20258                                     assert(ex == "-0.000000e+00************");
   20259                                     assert(ios.width() == 0);
   20260                                 }
   20261                                 ios.width(25);
   20262                                 right(ios);
   20263                                 {
   20264                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20265                                     std::string ex(str, iter.base());
   20266                                     assert(ex == "************-0.000000e+00");
   20267                                     assert(ios.width() == 0);
   20268                                 }
   20269                                 ios.width(25);
   20270                                 internal(ios);
   20271                                 {
   20272                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20273                                     std::string ex(str, iter.base());
   20274                                     assert(ex == "-************0.000000e+00");
   20275                                     assert(ios.width() == 0);
   20276                                 }
   20277                             }
   20278                             ios.imbue(lg);
   20279                             {
   20280                                 ios.width(0);
   20281                                 {
   20282                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20283                                     std::string ex(str, iter.base());
   20284                                     assert(ex == "-0;000000e+00");
   20285                                     assert(ios.width() == 0);
   20286                                 }
   20287                                 ios.width(25);
   20288                                 left(ios);
   20289                                 {
   20290                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20291                                     std::string ex(str, iter.base());
   20292                                     assert(ex == "-0;000000e+00************");
   20293                                     assert(ios.width() == 0);
   20294                                 }
   20295                                 ios.width(25);
   20296                                 right(ios);
   20297                                 {
   20298                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20299                                     std::string ex(str, iter.base());
   20300                                     assert(ex == "************-0;000000e+00");
   20301                                     assert(ios.width() == 0);
   20302                                 }
   20303                                 ios.width(25);
   20304                                 internal(ios);
   20305                                 {
   20306                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20307                                     std::string ex(str, iter.base());
   20308                                     assert(ex == "-************0;000000e+00");
   20309                                     assert(ios.width() == 0);
   20310                                 }
   20311                             }
   20312                         }
   20313                         showpoint(ios);
   20314                         {
   20315                             ios.imbue(lc);
   20316                             {
   20317                                 ios.width(0);
   20318                                 {
   20319                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20320                                     std::string ex(str, iter.base());
   20321                                     assert(ex == "-0.000000e+00");
   20322                                     assert(ios.width() == 0);
   20323                                 }
   20324                                 ios.width(25);
   20325                                 left(ios);
   20326                                 {
   20327                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20328                                     std::string ex(str, iter.base());
   20329                                     assert(ex == "-0.000000e+00************");
   20330                                     assert(ios.width() == 0);
   20331                                 }
   20332                                 ios.width(25);
   20333                                 right(ios);
   20334                                 {
   20335                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20336                                     std::string ex(str, iter.base());
   20337                                     assert(ex == "************-0.000000e+00");
   20338                                     assert(ios.width() == 0);
   20339                                 }
   20340                                 ios.width(25);
   20341                                 internal(ios);
   20342                                 {
   20343                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20344                                     std::string ex(str, iter.base());
   20345                                     assert(ex == "-************0.000000e+00");
   20346                                     assert(ios.width() == 0);
   20347                                 }
   20348                             }
   20349                             ios.imbue(lg);
   20350                             {
   20351                                 ios.width(0);
   20352                                 {
   20353                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20354                                     std::string ex(str, iter.base());
   20355                                     assert(ex == "-0;000000e+00");
   20356                                     assert(ios.width() == 0);
   20357                                 }
   20358                                 ios.width(25);
   20359                                 left(ios);
   20360                                 {
   20361                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20362                                     std::string ex(str, iter.base());
   20363                                     assert(ex == "-0;000000e+00************");
   20364                                     assert(ios.width() == 0);
   20365                                 }
   20366                                 ios.width(25);
   20367                                 right(ios);
   20368                                 {
   20369                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20370                                     std::string ex(str, iter.base());
   20371                                     assert(ex == "************-0;000000e+00");
   20372                                     assert(ios.width() == 0);
   20373                                 }
   20374                                 ios.width(25);
   20375                                 internal(ios);
   20376                                 {
   20377                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20378                                     std::string ex(str, iter.base());
   20379                                     assert(ex == "-************0;000000e+00");
   20380                                     assert(ios.width() == 0);
   20381                                 }
   20382                             }
   20383                         }
   20384                     }
   20385                     showpos(ios);
   20386                     {
   20387                         noshowpoint(ios);
   20388                         {
   20389                             ios.imbue(lc);
   20390                             {
   20391                                 ios.width(0);
   20392                                 {
   20393                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20394                                     std::string ex(str, iter.base());
   20395                                     assert(ex == "-0.000000e+00");
   20396                                     assert(ios.width() == 0);
   20397                                 }
   20398                                 ios.width(25);
   20399                                 left(ios);
   20400                                 {
   20401                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20402                                     std::string ex(str, iter.base());
   20403                                     assert(ex == "-0.000000e+00************");
   20404                                     assert(ios.width() == 0);
   20405                                 }
   20406                                 ios.width(25);
   20407                                 right(ios);
   20408                                 {
   20409                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20410                                     std::string ex(str, iter.base());
   20411                                     assert(ex == "************-0.000000e+00");
   20412                                     assert(ios.width() == 0);
   20413                                 }
   20414                                 ios.width(25);
   20415                                 internal(ios);
   20416                                 {
   20417                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20418                                     std::string ex(str, iter.base());
   20419                                     assert(ex == "-************0.000000e+00");
   20420                                     assert(ios.width() == 0);
   20421                                 }
   20422                             }
   20423                             ios.imbue(lg);
   20424                             {
   20425                                 ios.width(0);
   20426                                 {
   20427                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20428                                     std::string ex(str, iter.base());
   20429                                     assert(ex == "-0;000000e+00");
   20430                                     assert(ios.width() == 0);
   20431                                 }
   20432                                 ios.width(25);
   20433                                 left(ios);
   20434                                 {
   20435                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20436                                     std::string ex(str, iter.base());
   20437                                     assert(ex == "-0;000000e+00************");
   20438                                     assert(ios.width() == 0);
   20439                                 }
   20440                                 ios.width(25);
   20441                                 right(ios);
   20442                                 {
   20443                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20444                                     std::string ex(str, iter.base());
   20445                                     assert(ex == "************-0;000000e+00");
   20446                                     assert(ios.width() == 0);
   20447                                 }
   20448                                 ios.width(25);
   20449                                 internal(ios);
   20450                                 {
   20451                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20452                                     std::string ex(str, iter.base());
   20453                                     assert(ex == "-************0;000000e+00");
   20454                                     assert(ios.width() == 0);
   20455                                 }
   20456                             }
   20457                         }
   20458                         showpoint(ios);
   20459                         {
   20460                             ios.imbue(lc);
   20461                             {
   20462                                 ios.width(0);
   20463                                 {
   20464                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20465                                     std::string ex(str, iter.base());
   20466                                     assert(ex == "-0.000000e+00");
   20467                                     assert(ios.width() == 0);
   20468                                 }
   20469                                 ios.width(25);
   20470                                 left(ios);
   20471                                 {
   20472                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20473                                     std::string ex(str, iter.base());
   20474                                     assert(ex == "-0.000000e+00************");
   20475                                     assert(ios.width() == 0);
   20476                                 }
   20477                                 ios.width(25);
   20478                                 right(ios);
   20479                                 {
   20480                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20481                                     std::string ex(str, iter.base());
   20482                                     assert(ex == "************-0.000000e+00");
   20483                                     assert(ios.width() == 0);
   20484                                 }
   20485                                 ios.width(25);
   20486                                 internal(ios);
   20487                                 {
   20488                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20489                                     std::string ex(str, iter.base());
   20490                                     assert(ex == "-************0.000000e+00");
   20491                                     assert(ios.width() == 0);
   20492                                 }
   20493                             }
   20494                             ios.imbue(lg);
   20495                             {
   20496                                 ios.width(0);
   20497                                 {
   20498                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20499                                     std::string ex(str, iter.base());
   20500                                     assert(ex == "-0;000000e+00");
   20501                                     assert(ios.width() == 0);
   20502                                 }
   20503                                 ios.width(25);
   20504                                 left(ios);
   20505                                 {
   20506                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20507                                     std::string ex(str, iter.base());
   20508                                     assert(ex == "-0;000000e+00************");
   20509                                     assert(ios.width() == 0);
   20510                                 }
   20511                                 ios.width(25);
   20512                                 right(ios);
   20513                                 {
   20514                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20515                                     std::string ex(str, iter.base());
   20516                                     assert(ex == "************-0;000000e+00");
   20517                                     assert(ios.width() == 0);
   20518                                 }
   20519                                 ios.width(25);
   20520                                 internal(ios);
   20521                                 {
   20522                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20523                                     std::string ex(str, iter.base());
   20524                                     assert(ex == "-************0;000000e+00");
   20525                                     assert(ios.width() == 0);
   20526                                 }
   20527                             }
   20528                         }
   20529                     }
   20530                 }
   20531                 uppercase(ios);
   20532                 {
   20533                     noshowpos(ios);
   20534                     {
   20535                         noshowpoint(ios);
   20536                         {
   20537                             ios.imbue(lc);
   20538                             {
   20539                                 ios.width(0);
   20540                                 {
   20541                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20542                                     std::string ex(str, iter.base());
   20543                                     assert(ex == "-0.000000E+00");
   20544                                     assert(ios.width() == 0);
   20545                                 }
   20546                                 ios.width(25);
   20547                                 left(ios);
   20548                                 {
   20549                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20550                                     std::string ex(str, iter.base());
   20551                                     assert(ex == "-0.000000E+00************");
   20552                                     assert(ios.width() == 0);
   20553                                 }
   20554                                 ios.width(25);
   20555                                 right(ios);
   20556                                 {
   20557                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20558                                     std::string ex(str, iter.base());
   20559                                     assert(ex == "************-0.000000E+00");
   20560                                     assert(ios.width() == 0);
   20561                                 }
   20562                                 ios.width(25);
   20563                                 internal(ios);
   20564                                 {
   20565                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20566                                     std::string ex(str, iter.base());
   20567                                     assert(ex == "-************0.000000E+00");
   20568                                     assert(ios.width() == 0);
   20569                                 }
   20570                             }
   20571                             ios.imbue(lg);
   20572                             {
   20573                                 ios.width(0);
   20574                                 {
   20575                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20576                                     std::string ex(str, iter.base());
   20577                                     assert(ex == "-0;000000E+00");
   20578                                     assert(ios.width() == 0);
   20579                                 }
   20580                                 ios.width(25);
   20581                                 left(ios);
   20582                                 {
   20583                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20584                                     std::string ex(str, iter.base());
   20585                                     assert(ex == "-0;000000E+00************");
   20586                                     assert(ios.width() == 0);
   20587                                 }
   20588                                 ios.width(25);
   20589                                 right(ios);
   20590                                 {
   20591                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20592                                     std::string ex(str, iter.base());
   20593                                     assert(ex == "************-0;000000E+00");
   20594                                     assert(ios.width() == 0);
   20595                                 }
   20596                                 ios.width(25);
   20597                                 internal(ios);
   20598                                 {
   20599                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20600                                     std::string ex(str, iter.base());
   20601                                     assert(ex == "-************0;000000E+00");
   20602                                     assert(ios.width() == 0);
   20603                                 }
   20604                             }
   20605                         }
   20606                         showpoint(ios);
   20607                         {
   20608                             ios.imbue(lc);
   20609                             {
   20610                                 ios.width(0);
   20611                                 {
   20612                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20613                                     std::string ex(str, iter.base());
   20614                                     assert(ex == "-0.000000E+00");
   20615                                     assert(ios.width() == 0);
   20616                                 }
   20617                                 ios.width(25);
   20618                                 left(ios);
   20619                                 {
   20620                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20621                                     std::string ex(str, iter.base());
   20622                                     assert(ex == "-0.000000E+00************");
   20623                                     assert(ios.width() == 0);
   20624                                 }
   20625                                 ios.width(25);
   20626                                 right(ios);
   20627                                 {
   20628                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20629                                     std::string ex(str, iter.base());
   20630                                     assert(ex == "************-0.000000E+00");
   20631                                     assert(ios.width() == 0);
   20632                                 }
   20633                                 ios.width(25);
   20634                                 internal(ios);
   20635                                 {
   20636                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20637                                     std::string ex(str, iter.base());
   20638                                     assert(ex == "-************0.000000E+00");
   20639                                     assert(ios.width() == 0);
   20640                                 }
   20641                             }
   20642                             ios.imbue(lg);
   20643                             {
   20644                                 ios.width(0);
   20645                                 {
   20646                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20647                                     std::string ex(str, iter.base());
   20648                                     assert(ex == "-0;000000E+00");
   20649                                     assert(ios.width() == 0);
   20650                                 }
   20651                                 ios.width(25);
   20652                                 left(ios);
   20653                                 {
   20654                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20655                                     std::string ex(str, iter.base());
   20656                                     assert(ex == "-0;000000E+00************");
   20657                                     assert(ios.width() == 0);
   20658                                 }
   20659                                 ios.width(25);
   20660                                 right(ios);
   20661                                 {
   20662                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20663                                     std::string ex(str, iter.base());
   20664                                     assert(ex == "************-0;000000E+00");
   20665                                     assert(ios.width() == 0);
   20666                                 }
   20667                                 ios.width(25);
   20668                                 internal(ios);
   20669                                 {
   20670                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20671                                     std::string ex(str, iter.base());
   20672                                     assert(ex == "-************0;000000E+00");
   20673                                     assert(ios.width() == 0);
   20674                                 }
   20675                             }
   20676                         }
   20677                     }
   20678                     showpos(ios);
   20679                     {
   20680                         noshowpoint(ios);
   20681                         {
   20682                             ios.imbue(lc);
   20683                             {
   20684                                 ios.width(0);
   20685                                 {
   20686                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20687                                     std::string ex(str, iter.base());
   20688                                     assert(ex == "-0.000000E+00");
   20689                                     assert(ios.width() == 0);
   20690                                 }
   20691                                 ios.width(25);
   20692                                 left(ios);
   20693                                 {
   20694                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20695                                     std::string ex(str, iter.base());
   20696                                     assert(ex == "-0.000000E+00************");
   20697                                     assert(ios.width() == 0);
   20698                                 }
   20699                                 ios.width(25);
   20700                                 right(ios);
   20701                                 {
   20702                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20703                                     std::string ex(str, iter.base());
   20704                                     assert(ex == "************-0.000000E+00");
   20705                                     assert(ios.width() == 0);
   20706                                 }
   20707                                 ios.width(25);
   20708                                 internal(ios);
   20709                                 {
   20710                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20711                                     std::string ex(str, iter.base());
   20712                                     assert(ex == "-************0.000000E+00");
   20713                                     assert(ios.width() == 0);
   20714                                 }
   20715                             }
   20716                             ios.imbue(lg);
   20717                             {
   20718                                 ios.width(0);
   20719                                 {
   20720                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20721                                     std::string ex(str, iter.base());
   20722                                     assert(ex == "-0;000000E+00");
   20723                                     assert(ios.width() == 0);
   20724                                 }
   20725                                 ios.width(25);
   20726                                 left(ios);
   20727                                 {
   20728                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20729                                     std::string ex(str, iter.base());
   20730                                     assert(ex == "-0;000000E+00************");
   20731                                     assert(ios.width() == 0);
   20732                                 }
   20733                                 ios.width(25);
   20734                                 right(ios);
   20735                                 {
   20736                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20737                                     std::string ex(str, iter.base());
   20738                                     assert(ex == "************-0;000000E+00");
   20739                                     assert(ios.width() == 0);
   20740                                 }
   20741                                 ios.width(25);
   20742                                 internal(ios);
   20743                                 {
   20744                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20745                                     std::string ex(str, iter.base());
   20746                                     assert(ex == "-************0;000000E+00");
   20747                                     assert(ios.width() == 0);
   20748                                 }
   20749                             }
   20750                         }
   20751                         showpoint(ios);
   20752                         {
   20753                             ios.imbue(lc);
   20754                             {
   20755                                 ios.width(0);
   20756                                 {
   20757                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20758                                     std::string ex(str, iter.base());
   20759                                     assert(ex == "-0.000000E+00");
   20760                                     assert(ios.width() == 0);
   20761                                 }
   20762                                 ios.width(25);
   20763                                 left(ios);
   20764                                 {
   20765                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20766                                     std::string ex(str, iter.base());
   20767                                     assert(ex == "-0.000000E+00************");
   20768                                     assert(ios.width() == 0);
   20769                                 }
   20770                                 ios.width(25);
   20771                                 right(ios);
   20772                                 {
   20773                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20774                                     std::string ex(str, iter.base());
   20775                                     assert(ex == "************-0.000000E+00");
   20776                                     assert(ios.width() == 0);
   20777                                 }
   20778                                 ios.width(25);
   20779                                 internal(ios);
   20780                                 {
   20781                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20782                                     std::string ex(str, iter.base());
   20783                                     assert(ex == "-************0.000000E+00");
   20784                                     assert(ios.width() == 0);
   20785                                 }
   20786                             }
   20787                             ios.imbue(lg);
   20788                             {
   20789                                 ios.width(0);
   20790                                 {
   20791                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20792                                     std::string ex(str, iter.base());
   20793                                     assert(ex == "-0;000000E+00");
   20794                                     assert(ios.width() == 0);
   20795                                 }
   20796                                 ios.width(25);
   20797                                 left(ios);
   20798                                 {
   20799                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20800                                     std::string ex(str, iter.base());
   20801                                     assert(ex == "-0;000000E+00************");
   20802                                     assert(ios.width() == 0);
   20803                                 }
   20804                                 ios.width(25);
   20805                                 right(ios);
   20806                                 {
   20807                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20808                                     std::string ex(str, iter.base());
   20809                                     assert(ex == "************-0;000000E+00");
   20810                                     assert(ios.width() == 0);
   20811                                 }
   20812                                 ios.width(25);
   20813                                 internal(ios);
   20814                                 {
   20815                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20816                                     std::string ex(str, iter.base());
   20817                                     assert(ex == "-************0;000000E+00");
   20818                                     assert(ios.width() == 0);
   20819                                 }
   20820                             }
   20821                         }
   20822                     }
   20823                 }
   20824             }
   20825             ios.precision(16);
   20826             {
   20827             }
   20828             ios.precision(60);
   20829             {
   20830             }
   20831         }
   20832     }
   20833 }
   20834 
   20835 void test10()
   20836 {
   20837     char str[200];
   20838     output_iterator<char*> iter;
   20839     std::locale lc = std::locale::classic();
   20840     std::locale lg(lc, new my_numpunct);
   20841     const my_facet f(1);
   20842     {
   20843         long double v = 1234567890.125;
   20844         std::ios ios(0);
   20845         scientific(ios);
   20846         // %e
   20847         {
   20848             ios.precision(0);
   20849             {
   20850                 nouppercase(ios);
   20851                 {
   20852                     noshowpos(ios);
   20853                     {
   20854                         noshowpoint(ios);
   20855                         {
   20856                             ios.imbue(lc);
   20857                             {
   20858                                 ios.width(0);
   20859                                 {
   20860                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20861                                     std::string ex(str, iter.base());
   20862                                     assert(ex == "1e+09");
   20863                                     assert(ios.width() == 0);
   20864                                 }
   20865                                 ios.width(25);
   20866                                 left(ios);
   20867                                 {
   20868                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20869                                     std::string ex(str, iter.base());
   20870                                     assert(ex == "1e+09********************");
   20871                                     assert(ios.width() == 0);
   20872                                 }
   20873                                 ios.width(25);
   20874                                 right(ios);
   20875                                 {
   20876                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20877                                     std::string ex(str, iter.base());
   20878                                     assert(ex == "********************1e+09");
   20879                                     assert(ios.width() == 0);
   20880                                 }
   20881                                 ios.width(25);
   20882                                 internal(ios);
   20883                                 {
   20884                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20885                                     std::string ex(str, iter.base());
   20886                                     assert(ex == "********************1e+09");
   20887                                     assert(ios.width() == 0);
   20888                                 }
   20889                             }
   20890                             ios.imbue(lg);
   20891                             {
   20892                                 ios.width(0);
   20893                                 {
   20894                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20895                                     std::string ex(str, iter.base());
   20896                                     assert(ex == "1e+09");
   20897                                     assert(ios.width() == 0);
   20898                                 }
   20899                                 ios.width(25);
   20900                                 left(ios);
   20901                                 {
   20902                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20903                                     std::string ex(str, iter.base());
   20904                                     assert(ex == "1e+09********************");
   20905                                     assert(ios.width() == 0);
   20906                                 }
   20907                                 ios.width(25);
   20908                                 right(ios);
   20909                                 {
   20910                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20911                                     std::string ex(str, iter.base());
   20912                                     assert(ex == "********************1e+09");
   20913                                     assert(ios.width() == 0);
   20914                                 }
   20915                                 ios.width(25);
   20916                                 internal(ios);
   20917                                 {
   20918                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20919                                     std::string ex(str, iter.base());
   20920                                     assert(ex == "********************1e+09");
   20921                                     assert(ios.width() == 0);
   20922                                 }
   20923                             }
   20924                         }
   20925                         showpoint(ios);
   20926                         {
   20927                             ios.imbue(lc);
   20928                             {
   20929                                 ios.width(0);
   20930                                 {
   20931                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20932                                     std::string ex(str, iter.base());
   20933                                     assert(ex == "1.e+09");
   20934                                     assert(ios.width() == 0);
   20935                                 }
   20936                                 ios.width(25);
   20937                                 left(ios);
   20938                                 {
   20939                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20940                                     std::string ex(str, iter.base());
   20941                                     assert(ex == "1.e+09*******************");
   20942                                     assert(ios.width() == 0);
   20943                                 }
   20944                                 ios.width(25);
   20945                                 right(ios);
   20946                                 {
   20947                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20948                                     std::string ex(str, iter.base());
   20949                                     assert(ex == "*******************1.e+09");
   20950                                     assert(ios.width() == 0);
   20951                                 }
   20952                                 ios.width(25);
   20953                                 internal(ios);
   20954                                 {
   20955                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20956                                     std::string ex(str, iter.base());
   20957                                     assert(ex == "*******************1.e+09");
   20958                                     assert(ios.width() == 0);
   20959                                 }
   20960                             }
   20961                             ios.imbue(lg);
   20962                             {
   20963                                 ios.width(0);
   20964                                 {
   20965                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20966                                     std::string ex(str, iter.base());
   20967                                     assert(ex == "1;e+09");
   20968                                     assert(ios.width() == 0);
   20969                                 }
   20970                                 ios.width(25);
   20971                                 left(ios);
   20972                                 {
   20973                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20974                                     std::string ex(str, iter.base());
   20975                                     assert(ex == "1;e+09*******************");
   20976                                     assert(ios.width() == 0);
   20977                                 }
   20978                                 ios.width(25);
   20979                                 right(ios);
   20980                                 {
   20981                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20982                                     std::string ex(str, iter.base());
   20983                                     assert(ex == "*******************1;e+09");
   20984                                     assert(ios.width() == 0);
   20985                                 }
   20986                                 ios.width(25);
   20987                                 internal(ios);
   20988                                 {
   20989                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20990                                     std::string ex(str, iter.base());
   20991                                     assert(ex == "*******************1;e+09");
   20992                                     assert(ios.width() == 0);
   20993                                 }
   20994                             }
   20995                         }
   20996                     }
   20997                     showpos(ios);
   20998                     {
   20999                         noshowpoint(ios);
   21000                         {
   21001                             ios.imbue(lc);
   21002                             {
   21003                                 ios.width(0);
   21004                                 {
   21005                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21006                                     std::string ex(str, iter.base());
   21007                                     assert(ex == "+1e+09");
   21008                                     assert(ios.width() == 0);
   21009                                 }
   21010                                 ios.width(25);
   21011                                 left(ios);
   21012                                 {
   21013                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21014                                     std::string ex(str, iter.base());
   21015                                     assert(ex == "+1e+09*******************");
   21016                                     assert(ios.width() == 0);
   21017                                 }
   21018                                 ios.width(25);
   21019                                 right(ios);
   21020                                 {
   21021                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21022                                     std::string ex(str, iter.base());
   21023                                     assert(ex == "*******************+1e+09");
   21024                                     assert(ios.width() == 0);
   21025                                 }
   21026                                 ios.width(25);
   21027                                 internal(ios);
   21028                                 {
   21029                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21030                                     std::string ex(str, iter.base());
   21031                                     assert(ex == "+*******************1e+09");
   21032                                     assert(ios.width() == 0);
   21033                                 }
   21034                             }
   21035                             ios.imbue(lg);
   21036                             {
   21037                                 ios.width(0);
   21038                                 {
   21039                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21040                                     std::string ex(str, iter.base());
   21041                                     assert(ex == "+1e+09");
   21042                                     assert(ios.width() == 0);
   21043                                 }
   21044                                 ios.width(25);
   21045                                 left(ios);
   21046                                 {
   21047                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21048                                     std::string ex(str, iter.base());
   21049                                     assert(ex == "+1e+09*******************");
   21050                                     assert(ios.width() == 0);
   21051                                 }
   21052                                 ios.width(25);
   21053                                 right(ios);
   21054                                 {
   21055                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21056                                     std::string ex(str, iter.base());
   21057                                     assert(ex == "*******************+1e+09");
   21058                                     assert(ios.width() == 0);
   21059                                 }
   21060                                 ios.width(25);
   21061                                 internal(ios);
   21062                                 {
   21063                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21064                                     std::string ex(str, iter.base());
   21065                                     assert(ex == "+*******************1e+09");
   21066                                     assert(ios.width() == 0);
   21067                                 }
   21068                             }
   21069                         }
   21070                         showpoint(ios);
   21071                         {
   21072                             ios.imbue(lc);
   21073                             {
   21074                                 ios.width(0);
   21075                                 {
   21076                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21077                                     std::string ex(str, iter.base());
   21078                                     assert(ex == "+1.e+09");
   21079                                     assert(ios.width() == 0);
   21080                                 }
   21081                                 ios.width(25);
   21082                                 left(ios);
   21083                                 {
   21084                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21085                                     std::string ex(str, iter.base());
   21086                                     assert(ex == "+1.e+09******************");
   21087                                     assert(ios.width() == 0);
   21088                                 }
   21089                                 ios.width(25);
   21090                                 right(ios);
   21091                                 {
   21092                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21093                                     std::string ex(str, iter.base());
   21094                                     assert(ex == "******************+1.e+09");
   21095                                     assert(ios.width() == 0);
   21096                                 }
   21097                                 ios.width(25);
   21098                                 internal(ios);
   21099                                 {
   21100                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21101                                     std::string ex(str, iter.base());
   21102                                     assert(ex == "+******************1.e+09");
   21103                                     assert(ios.width() == 0);
   21104                                 }
   21105                             }
   21106                             ios.imbue(lg);
   21107                             {
   21108                                 ios.width(0);
   21109                                 {
   21110                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21111                                     std::string ex(str, iter.base());
   21112                                     assert(ex == "+1;e+09");
   21113                                     assert(ios.width() == 0);
   21114                                 }
   21115                                 ios.width(25);
   21116                                 left(ios);
   21117                                 {
   21118                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21119                                     std::string ex(str, iter.base());
   21120                                     assert(ex == "+1;e+09******************");
   21121                                     assert(ios.width() == 0);
   21122                                 }
   21123                                 ios.width(25);
   21124                                 right(ios);
   21125                                 {
   21126                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21127                                     std::string ex(str, iter.base());
   21128                                     assert(ex == "******************+1;e+09");
   21129                                     assert(ios.width() == 0);
   21130                                 }
   21131                                 ios.width(25);
   21132                                 internal(ios);
   21133                                 {
   21134                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21135                                     std::string ex(str, iter.base());
   21136                                     assert(ex == "+******************1;e+09");
   21137                                     assert(ios.width() == 0);
   21138                                 }
   21139                             }
   21140                         }
   21141                     }
   21142                 }
   21143                 uppercase(ios);
   21144                 {
   21145                     noshowpos(ios);
   21146                     {
   21147                         noshowpoint(ios);
   21148                         {
   21149                             ios.imbue(lc);
   21150                             {
   21151                                 ios.width(0);
   21152                                 {
   21153                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21154                                     std::string ex(str, iter.base());
   21155                                     assert(ex == "1E+09");
   21156                                     assert(ios.width() == 0);
   21157                                 }
   21158                                 ios.width(25);
   21159                                 left(ios);
   21160                                 {
   21161                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21162                                     std::string ex(str, iter.base());
   21163                                     assert(ex == "1E+09********************");
   21164                                     assert(ios.width() == 0);
   21165                                 }
   21166                                 ios.width(25);
   21167                                 right(ios);
   21168                                 {
   21169                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21170                                     std::string ex(str, iter.base());
   21171                                     assert(ex == "********************1E+09");
   21172                                     assert(ios.width() == 0);
   21173                                 }
   21174                                 ios.width(25);
   21175                                 internal(ios);
   21176                                 {
   21177                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21178                                     std::string ex(str, iter.base());
   21179                                     assert(ex == "********************1E+09");
   21180                                     assert(ios.width() == 0);
   21181                                 }
   21182                             }
   21183                             ios.imbue(lg);
   21184                             {
   21185                                 ios.width(0);
   21186                                 {
   21187                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21188                                     std::string ex(str, iter.base());
   21189                                     assert(ex == "1E+09");
   21190                                     assert(ios.width() == 0);
   21191                                 }
   21192                                 ios.width(25);
   21193                                 left(ios);
   21194                                 {
   21195                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21196                                     std::string ex(str, iter.base());
   21197                                     assert(ex == "1E+09********************");
   21198                                     assert(ios.width() == 0);
   21199                                 }
   21200                                 ios.width(25);
   21201                                 right(ios);
   21202                                 {
   21203                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21204                                     std::string ex(str, iter.base());
   21205                                     assert(ex == "********************1E+09");
   21206                                     assert(ios.width() == 0);
   21207                                 }
   21208                                 ios.width(25);
   21209                                 internal(ios);
   21210                                 {
   21211                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21212                                     std::string ex(str, iter.base());
   21213                                     assert(ex == "********************1E+09");
   21214                                     assert(ios.width() == 0);
   21215                                 }
   21216                             }
   21217                         }
   21218                         showpoint(ios);
   21219                         {
   21220                             ios.imbue(lc);
   21221                             {
   21222                                 ios.width(0);
   21223                                 {
   21224                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21225                                     std::string ex(str, iter.base());
   21226                                     assert(ex == "1.E+09");
   21227                                     assert(ios.width() == 0);
   21228                                 }
   21229                                 ios.width(25);
   21230                                 left(ios);
   21231                                 {
   21232                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21233                                     std::string ex(str, iter.base());
   21234                                     assert(ex == "1.E+09*******************");
   21235                                     assert(ios.width() == 0);
   21236                                 }
   21237                                 ios.width(25);
   21238                                 right(ios);
   21239                                 {
   21240                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21241                                     std::string ex(str, iter.base());
   21242                                     assert(ex == "*******************1.E+09");
   21243                                     assert(ios.width() == 0);
   21244                                 }
   21245                                 ios.width(25);
   21246                                 internal(ios);
   21247                                 {
   21248                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21249                                     std::string ex(str, iter.base());
   21250                                     assert(ex == "*******************1.E+09");
   21251                                     assert(ios.width() == 0);
   21252                                 }
   21253                             }
   21254                             ios.imbue(lg);
   21255                             {
   21256                                 ios.width(0);
   21257                                 {
   21258                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21259                                     std::string ex(str, iter.base());
   21260                                     assert(ex == "1;E+09");
   21261                                     assert(ios.width() == 0);
   21262                                 }
   21263                                 ios.width(25);
   21264                                 left(ios);
   21265                                 {
   21266                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21267                                     std::string ex(str, iter.base());
   21268                                     assert(ex == "1;E+09*******************");
   21269                                     assert(ios.width() == 0);
   21270                                 }
   21271                                 ios.width(25);
   21272                                 right(ios);
   21273                                 {
   21274                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21275                                     std::string ex(str, iter.base());
   21276                                     assert(ex == "*******************1;E+09");
   21277                                     assert(ios.width() == 0);
   21278                                 }
   21279                                 ios.width(25);
   21280                                 internal(ios);
   21281                                 {
   21282                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21283                                     std::string ex(str, iter.base());
   21284                                     assert(ex == "*******************1;E+09");
   21285                                     assert(ios.width() == 0);
   21286                                 }
   21287                             }
   21288                         }
   21289                     }
   21290                     showpos(ios);
   21291                     {
   21292                         noshowpoint(ios);
   21293                         {
   21294                             ios.imbue(lc);
   21295                             {
   21296                                 ios.width(0);
   21297                                 {
   21298                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21299                                     std::string ex(str, iter.base());
   21300                                     assert(ex == "+1E+09");
   21301                                     assert(ios.width() == 0);
   21302                                 }
   21303                                 ios.width(25);
   21304                                 left(ios);
   21305                                 {
   21306                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21307                                     std::string ex(str, iter.base());
   21308                                     assert(ex == "+1E+09*******************");
   21309                                     assert(ios.width() == 0);
   21310                                 }
   21311                                 ios.width(25);
   21312                                 right(ios);
   21313                                 {
   21314                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21315                                     std::string ex(str, iter.base());
   21316                                     assert(ex == "*******************+1E+09");
   21317                                     assert(ios.width() == 0);
   21318                                 }
   21319                                 ios.width(25);
   21320                                 internal(ios);
   21321                                 {
   21322                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21323                                     std::string ex(str, iter.base());
   21324                                     assert(ex == "+*******************1E+09");
   21325                                     assert(ios.width() == 0);
   21326                                 }
   21327                             }
   21328                             ios.imbue(lg);
   21329                             {
   21330                                 ios.width(0);
   21331                                 {
   21332                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21333                                     std::string ex(str, iter.base());
   21334                                     assert(ex == "+1E+09");
   21335                                     assert(ios.width() == 0);
   21336                                 }
   21337                                 ios.width(25);
   21338                                 left(ios);
   21339                                 {
   21340                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21341                                     std::string ex(str, iter.base());
   21342                                     assert(ex == "+1E+09*******************");
   21343                                     assert(ios.width() == 0);
   21344                                 }
   21345                                 ios.width(25);
   21346                                 right(ios);
   21347                                 {
   21348                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21349                                     std::string ex(str, iter.base());
   21350                                     assert(ex == "*******************+1E+09");
   21351                                     assert(ios.width() == 0);
   21352                                 }
   21353                                 ios.width(25);
   21354                                 internal(ios);
   21355                                 {
   21356                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21357                                     std::string ex(str, iter.base());
   21358                                     assert(ex == "+*******************1E+09");
   21359                                     assert(ios.width() == 0);
   21360                                 }
   21361                             }
   21362                         }
   21363                         showpoint(ios);
   21364                         {
   21365                             ios.imbue(lc);
   21366                             {
   21367                                 ios.width(0);
   21368                                 {
   21369                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21370                                     std::string ex(str, iter.base());
   21371                                     assert(ex == "+1.E+09");
   21372                                     assert(ios.width() == 0);
   21373                                 }
   21374                                 ios.width(25);
   21375                                 left(ios);
   21376                                 {
   21377                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21378                                     std::string ex(str, iter.base());
   21379                                     assert(ex == "+1.E+09******************");
   21380                                     assert(ios.width() == 0);
   21381                                 }
   21382                                 ios.width(25);
   21383                                 right(ios);
   21384                                 {
   21385                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21386                                     std::string ex(str, iter.base());
   21387                                     assert(ex == "******************+1.E+09");
   21388                                     assert(ios.width() == 0);
   21389                                 }
   21390                                 ios.width(25);
   21391                                 internal(ios);
   21392                                 {
   21393                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21394                                     std::string ex(str, iter.base());
   21395                                     assert(ex == "+******************1.E+09");
   21396                                     assert(ios.width() == 0);
   21397                                 }
   21398                             }
   21399                             ios.imbue(lg);
   21400                             {
   21401                                 ios.width(0);
   21402                                 {
   21403                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21404                                     std::string ex(str, iter.base());
   21405                                     assert(ex == "+1;E+09");
   21406                                     assert(ios.width() == 0);
   21407                                 }
   21408                                 ios.width(25);
   21409                                 left(ios);
   21410                                 {
   21411                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21412                                     std::string ex(str, iter.base());
   21413                                     assert(ex == "+1;E+09******************");
   21414                                     assert(ios.width() == 0);
   21415                                 }
   21416                                 ios.width(25);
   21417                                 right(ios);
   21418                                 {
   21419                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21420                                     std::string ex(str, iter.base());
   21421                                     assert(ex == "******************+1;E+09");
   21422                                     assert(ios.width() == 0);
   21423                                 }
   21424                                 ios.width(25);
   21425                                 internal(ios);
   21426                                 {
   21427                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21428                                     std::string ex(str, iter.base());
   21429                                     assert(ex == "+******************1;E+09");
   21430                                     assert(ios.width() == 0);
   21431                                 }
   21432                             }
   21433                         }
   21434                     }
   21435                 }
   21436             }
   21437             ios.precision(1);
   21438             {
   21439                 nouppercase(ios);
   21440                 {
   21441                     noshowpos(ios);
   21442                     {
   21443                         noshowpoint(ios);
   21444                         {
   21445                             ios.imbue(lc);
   21446                             {
   21447                                 ios.width(0);
   21448                                 {
   21449                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21450                                     std::string ex(str, iter.base());
   21451                                     assert(ex == "1.2e+09");
   21452                                     assert(ios.width() == 0);
   21453                                 }
   21454                                 ios.width(25);
   21455                                 left(ios);
   21456                                 {
   21457                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21458                                     std::string ex(str, iter.base());
   21459                                     assert(ex == "1.2e+09******************");
   21460                                     assert(ios.width() == 0);
   21461                                 }
   21462                                 ios.width(25);
   21463                                 right(ios);
   21464                                 {
   21465                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21466                                     std::string ex(str, iter.base());
   21467                                     assert(ex == "******************1.2e+09");
   21468                                     assert(ios.width() == 0);
   21469                                 }
   21470                                 ios.width(25);
   21471                                 internal(ios);
   21472                                 {
   21473                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21474                                     std::string ex(str, iter.base());
   21475                                     assert(ex == "******************1.2e+09");
   21476                                     assert(ios.width() == 0);
   21477                                 }
   21478                             }
   21479                             ios.imbue(lg);
   21480                             {
   21481                                 ios.width(0);
   21482                                 {
   21483                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21484                                     std::string ex(str, iter.base());
   21485                                     assert(ex == "1;2e+09");
   21486                                     assert(ios.width() == 0);
   21487                                 }
   21488                                 ios.width(25);
   21489                                 left(ios);
   21490                                 {
   21491                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21492                                     std::string ex(str, iter.base());
   21493                                     assert(ex == "1;2e+09******************");
   21494                                     assert(ios.width() == 0);
   21495                                 }
   21496                                 ios.width(25);
   21497                                 right(ios);
   21498                                 {
   21499                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21500                                     std::string ex(str, iter.base());
   21501                                     assert(ex == "******************1;2e+09");
   21502                                     assert(ios.width() == 0);
   21503                                 }
   21504                                 ios.width(25);
   21505                                 internal(ios);
   21506                                 {
   21507                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21508                                     std::string ex(str, iter.base());
   21509                                     assert(ex == "******************1;2e+09");
   21510                                     assert(ios.width() == 0);
   21511                                 }
   21512                             }
   21513                         }
   21514                         showpoint(ios);
   21515                         {
   21516                             ios.imbue(lc);
   21517                             {
   21518                                 ios.width(0);
   21519                                 {
   21520                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21521                                     std::string ex(str, iter.base());
   21522                                     assert(ex == "1.2e+09");
   21523                                     assert(ios.width() == 0);
   21524                                 }
   21525                                 ios.width(25);
   21526                                 left(ios);
   21527                                 {
   21528                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21529                                     std::string ex(str, iter.base());
   21530                                     assert(ex == "1.2e+09******************");
   21531                                     assert(ios.width() == 0);
   21532                                 }
   21533                                 ios.width(25);
   21534                                 right(ios);
   21535                                 {
   21536                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21537                                     std::string ex(str, iter.base());
   21538                                     assert(ex == "******************1.2e+09");
   21539                                     assert(ios.width() == 0);
   21540                                 }
   21541                                 ios.width(25);
   21542                                 internal(ios);
   21543                                 {
   21544                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21545                                     std::string ex(str, iter.base());
   21546                                     assert(ex == "******************1.2e+09");
   21547                                     assert(ios.width() == 0);
   21548                                 }
   21549                             }
   21550                             ios.imbue(lg);
   21551                             {
   21552                                 ios.width(0);
   21553                                 {
   21554                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21555                                     std::string ex(str, iter.base());
   21556                                     assert(ex == "1;2e+09");
   21557                                     assert(ios.width() == 0);
   21558                                 }
   21559                                 ios.width(25);
   21560                                 left(ios);
   21561                                 {
   21562                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21563                                     std::string ex(str, iter.base());
   21564                                     assert(ex == "1;2e+09******************");
   21565                                     assert(ios.width() == 0);
   21566                                 }
   21567                                 ios.width(25);
   21568                                 right(ios);
   21569                                 {
   21570                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21571                                     std::string ex(str, iter.base());
   21572                                     assert(ex == "******************1;2e+09");
   21573                                     assert(ios.width() == 0);
   21574                                 }
   21575                                 ios.width(25);
   21576                                 internal(ios);
   21577                                 {
   21578                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21579                                     std::string ex(str, iter.base());
   21580                                     assert(ex == "******************1;2e+09");
   21581                                     assert(ios.width() == 0);
   21582                                 }
   21583                             }
   21584                         }
   21585                     }
   21586                     showpos(ios);
   21587                     {
   21588                         noshowpoint(ios);
   21589                         {
   21590                             ios.imbue(lc);
   21591                             {
   21592                                 ios.width(0);
   21593                                 {
   21594                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21595                                     std::string ex(str, iter.base());
   21596                                     assert(ex == "+1.2e+09");
   21597                                     assert(ios.width() == 0);
   21598                                 }
   21599                                 ios.width(25);
   21600                                 left(ios);
   21601                                 {
   21602                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21603                                     std::string ex(str, iter.base());
   21604                                     assert(ex == "+1.2e+09*****************");
   21605                                     assert(ios.width() == 0);
   21606                                 }
   21607                                 ios.width(25);
   21608                                 right(ios);
   21609                                 {
   21610                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21611                                     std::string ex(str, iter.base());
   21612                                     assert(ex == "*****************+1.2e+09");
   21613                                     assert(ios.width() == 0);
   21614                                 }
   21615                                 ios.width(25);
   21616                                 internal(ios);
   21617                                 {
   21618                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21619                                     std::string ex(str, iter.base());
   21620                                     assert(ex == "+*****************1.2e+09");
   21621                                     assert(ios.width() == 0);
   21622                                 }
   21623                             }
   21624                             ios.imbue(lg);
   21625                             {
   21626                                 ios.width(0);
   21627                                 {
   21628                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21629                                     std::string ex(str, iter.base());
   21630                                     assert(ex == "+1;2e+09");
   21631                                     assert(ios.width() == 0);
   21632                                 }
   21633                                 ios.width(25);
   21634                                 left(ios);
   21635                                 {
   21636                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21637                                     std::string ex(str, iter.base());
   21638                                     assert(ex == "+1;2e+09*****************");
   21639                                     assert(ios.width() == 0);
   21640                                 }
   21641                                 ios.width(25);
   21642                                 right(ios);
   21643                                 {
   21644                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21645                                     std::string ex(str, iter.base());
   21646                                     assert(ex == "*****************+1;2e+09");
   21647                                     assert(ios.width() == 0);
   21648                                 }
   21649                                 ios.width(25);
   21650                                 internal(ios);
   21651                                 {
   21652                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21653                                     std::string ex(str, iter.base());
   21654                                     assert(ex == "+*****************1;2e+09");
   21655                                     assert(ios.width() == 0);
   21656                                 }
   21657                             }
   21658                         }
   21659                         showpoint(ios);
   21660                         {
   21661                             ios.imbue(lc);
   21662                             {
   21663                                 ios.width(0);
   21664                                 {
   21665                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21666                                     std::string ex(str, iter.base());
   21667                                     assert(ex == "+1.2e+09");
   21668                                     assert(ios.width() == 0);
   21669                                 }
   21670                                 ios.width(25);
   21671                                 left(ios);
   21672                                 {
   21673                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21674                                     std::string ex(str, iter.base());
   21675                                     assert(ex == "+1.2e+09*****************");
   21676                                     assert(ios.width() == 0);
   21677                                 }
   21678                                 ios.width(25);
   21679                                 right(ios);
   21680                                 {
   21681                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21682                                     std::string ex(str, iter.base());
   21683                                     assert(ex == "*****************+1.2e+09");
   21684                                     assert(ios.width() == 0);
   21685                                 }
   21686                                 ios.width(25);
   21687                                 internal(ios);
   21688                                 {
   21689                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21690                                     std::string ex(str, iter.base());
   21691                                     assert(ex == "+*****************1.2e+09");
   21692                                     assert(ios.width() == 0);
   21693                                 }
   21694                             }
   21695                             ios.imbue(lg);
   21696                             {
   21697                                 ios.width(0);
   21698                                 {
   21699                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21700                                     std::string ex(str, iter.base());
   21701                                     assert(ex == "+1;2e+09");
   21702                                     assert(ios.width() == 0);
   21703                                 }
   21704                                 ios.width(25);
   21705                                 left(ios);
   21706                                 {
   21707                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21708                                     std::string ex(str, iter.base());
   21709                                     assert(ex == "+1;2e+09*****************");
   21710                                     assert(ios.width() == 0);
   21711                                 }
   21712                                 ios.width(25);
   21713                                 right(ios);
   21714                                 {
   21715                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21716                                     std::string ex(str, iter.base());
   21717                                     assert(ex == "*****************+1;2e+09");
   21718                                     assert(ios.width() == 0);
   21719                                 }
   21720                                 ios.width(25);
   21721                                 internal(ios);
   21722                                 {
   21723                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21724                                     std::string ex(str, iter.base());
   21725                                     assert(ex == "+*****************1;2e+09");
   21726                                     assert(ios.width() == 0);
   21727                                 }
   21728                             }
   21729                         }
   21730                     }
   21731                 }
   21732                 uppercase(ios);
   21733                 {
   21734                     noshowpos(ios);
   21735                     {
   21736                         noshowpoint(ios);
   21737                         {
   21738                             ios.imbue(lc);
   21739                             {
   21740                                 ios.width(0);
   21741                                 {
   21742                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21743                                     std::string ex(str, iter.base());
   21744                                     assert(ex == "1.2E+09");
   21745                                     assert(ios.width() == 0);
   21746                                 }
   21747                                 ios.width(25);
   21748                                 left(ios);
   21749                                 {
   21750                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21751                                     std::string ex(str, iter.base());
   21752                                     assert(ex == "1.2E+09******************");
   21753                                     assert(ios.width() == 0);
   21754                                 }
   21755                                 ios.width(25);
   21756                                 right(ios);
   21757                                 {
   21758                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21759                                     std::string ex(str, iter.base());
   21760                                     assert(ex == "******************1.2E+09");
   21761                                     assert(ios.width() == 0);
   21762                                 }
   21763                                 ios.width(25);
   21764                                 internal(ios);
   21765                                 {
   21766                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21767                                     std::string ex(str, iter.base());
   21768                                     assert(ex == "******************1.2E+09");
   21769                                     assert(ios.width() == 0);
   21770                                 }
   21771                             }
   21772                             ios.imbue(lg);
   21773                             {
   21774                                 ios.width(0);
   21775                                 {
   21776                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21777                                     std::string ex(str, iter.base());
   21778                                     assert(ex == "1;2E+09");
   21779                                     assert(ios.width() == 0);
   21780                                 }
   21781                                 ios.width(25);
   21782                                 left(ios);
   21783                                 {
   21784                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21785                                     std::string ex(str, iter.base());
   21786                                     assert(ex == "1;2E+09******************");
   21787                                     assert(ios.width() == 0);
   21788                                 }
   21789                                 ios.width(25);
   21790                                 right(ios);
   21791                                 {
   21792                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21793                                     std::string ex(str, iter.base());
   21794                                     assert(ex == "******************1;2E+09");
   21795                                     assert(ios.width() == 0);
   21796                                 }
   21797                                 ios.width(25);
   21798                                 internal(ios);
   21799                                 {
   21800                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21801                                     std::string ex(str, iter.base());
   21802                                     assert(ex == "******************1;2E+09");
   21803                                     assert(ios.width() == 0);
   21804                                 }
   21805                             }
   21806                         }
   21807                         showpoint(ios);
   21808                         {
   21809                             ios.imbue(lc);
   21810                             {
   21811                                 ios.width(0);
   21812                                 {
   21813                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21814                                     std::string ex(str, iter.base());
   21815                                     assert(ex == "1.2E+09");
   21816                                     assert(ios.width() == 0);
   21817                                 }
   21818                                 ios.width(25);
   21819                                 left(ios);
   21820                                 {
   21821                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21822                                     std::string ex(str, iter.base());
   21823                                     assert(ex == "1.2E+09******************");
   21824                                     assert(ios.width() == 0);
   21825                                 }
   21826                                 ios.width(25);
   21827                                 right(ios);
   21828                                 {
   21829                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21830                                     std::string ex(str, iter.base());
   21831                                     assert(ex == "******************1.2E+09");
   21832                                     assert(ios.width() == 0);
   21833                                 }
   21834                                 ios.width(25);
   21835                                 internal(ios);
   21836                                 {
   21837                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21838                                     std::string ex(str, iter.base());
   21839                                     assert(ex == "******************1.2E+09");
   21840                                     assert(ios.width() == 0);
   21841                                 }
   21842                             }
   21843                             ios.imbue(lg);
   21844                             {
   21845                                 ios.width(0);
   21846                                 {
   21847                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21848                                     std::string ex(str, iter.base());
   21849                                     assert(ex == "1;2E+09");
   21850                                     assert(ios.width() == 0);
   21851                                 }
   21852                                 ios.width(25);
   21853                                 left(ios);
   21854                                 {
   21855                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21856                                     std::string ex(str, iter.base());
   21857                                     assert(ex == "1;2E+09******************");
   21858                                     assert(ios.width() == 0);
   21859                                 }
   21860                                 ios.width(25);
   21861                                 right(ios);
   21862                                 {
   21863                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21864                                     std::string ex(str, iter.base());
   21865                                     assert(ex == "******************1;2E+09");
   21866                                     assert(ios.width() == 0);
   21867                                 }
   21868                                 ios.width(25);
   21869                                 internal(ios);
   21870                                 {
   21871                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21872                                     std::string ex(str, iter.base());
   21873                                     assert(ex == "******************1;2E+09");
   21874                                     assert(ios.width() == 0);
   21875                                 }
   21876                             }
   21877                         }
   21878                     }
   21879                     showpos(ios);
   21880                     {
   21881                         noshowpoint(ios);
   21882                         {
   21883                             ios.imbue(lc);
   21884                             {
   21885                                 ios.width(0);
   21886                                 {
   21887                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21888                                     std::string ex(str, iter.base());
   21889                                     assert(ex == "+1.2E+09");
   21890                                     assert(ios.width() == 0);
   21891                                 }
   21892                                 ios.width(25);
   21893                                 left(ios);
   21894                                 {
   21895                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21896                                     std::string ex(str, iter.base());
   21897                                     assert(ex == "+1.2E+09*****************");
   21898                                     assert(ios.width() == 0);
   21899                                 }
   21900                                 ios.width(25);
   21901                                 right(ios);
   21902                                 {
   21903                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21904                                     std::string ex(str, iter.base());
   21905                                     assert(ex == "*****************+1.2E+09");
   21906                                     assert(ios.width() == 0);
   21907                                 }
   21908                                 ios.width(25);
   21909                                 internal(ios);
   21910                                 {
   21911                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21912                                     std::string ex(str, iter.base());
   21913                                     assert(ex == "+*****************1.2E+09");
   21914                                     assert(ios.width() == 0);
   21915                                 }
   21916                             }
   21917                             ios.imbue(lg);
   21918                             {
   21919                                 ios.width(0);
   21920                                 {
   21921                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21922                                     std::string ex(str, iter.base());
   21923                                     assert(ex == "+1;2E+09");
   21924                                     assert(ios.width() == 0);
   21925                                 }
   21926                                 ios.width(25);
   21927                                 left(ios);
   21928                                 {
   21929                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21930                                     std::string ex(str, iter.base());
   21931                                     assert(ex == "+1;2E+09*****************");
   21932                                     assert(ios.width() == 0);
   21933                                 }
   21934                                 ios.width(25);
   21935                                 right(ios);
   21936                                 {
   21937                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21938                                     std::string ex(str, iter.base());
   21939                                     assert(ex == "*****************+1;2E+09");
   21940                                     assert(ios.width() == 0);
   21941                                 }
   21942                                 ios.width(25);
   21943                                 internal(ios);
   21944                                 {
   21945                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21946                                     std::string ex(str, iter.base());
   21947                                     assert(ex == "+*****************1;2E+09");
   21948                                     assert(ios.width() == 0);
   21949                                 }
   21950                             }
   21951                         }
   21952                         showpoint(ios);
   21953                         {
   21954                             ios.imbue(lc);
   21955                             {
   21956                                 ios.width(0);
   21957                                 {
   21958                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21959                                     std::string ex(str, iter.base());
   21960                                     assert(ex == "+1.2E+09");
   21961                                     assert(ios.width() == 0);
   21962                                 }
   21963                                 ios.width(25);
   21964                                 left(ios);
   21965                                 {
   21966                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21967                                     std::string ex(str, iter.base());
   21968                                     assert(ex == "+1.2E+09*****************");
   21969                                     assert(ios.width() == 0);
   21970                                 }
   21971                                 ios.width(25);
   21972                                 right(ios);
   21973                                 {
   21974                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21975                                     std::string ex(str, iter.base());
   21976                                     assert(ex == "*****************+1.2E+09");
   21977                                     assert(ios.width() == 0);
   21978                                 }
   21979                                 ios.width(25);
   21980                                 internal(ios);
   21981                                 {
   21982                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21983                                     std::string ex(str, iter.base());
   21984                                     assert(ex == "+*****************1.2E+09");
   21985                                     assert(ios.width() == 0);
   21986                                 }
   21987                             }
   21988                             ios.imbue(lg);
   21989                             {
   21990                                 ios.width(0);
   21991                                 {
   21992                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21993                                     std::string ex(str, iter.base());
   21994                                     assert(ex == "+1;2E+09");
   21995                                     assert(ios.width() == 0);
   21996                                 }
   21997                                 ios.width(25);
   21998                                 left(ios);
   21999                                 {
   22000                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22001                                     std::string ex(str, iter.base());
   22002                                     assert(ex == "+1;2E+09*****************");
   22003                                     assert(ios.width() == 0);
   22004                                 }
   22005                                 ios.width(25);
   22006                                 right(ios);
   22007                                 {
   22008                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22009                                     std::string ex(str, iter.base());
   22010                                     assert(ex == "*****************+1;2E+09");
   22011                                     assert(ios.width() == 0);
   22012                                 }
   22013                                 ios.width(25);
   22014                                 internal(ios);
   22015                                 {
   22016                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22017                                     std::string ex(str, iter.base());
   22018                                     assert(ex == "+*****************1;2E+09");
   22019                                     assert(ios.width() == 0);
   22020                                 }
   22021                             }
   22022                         }
   22023                     }
   22024                 }
   22025             }
   22026             ios.precision(6);
   22027             {
   22028             }
   22029             ios.precision(16);
   22030             {
   22031             }
   22032             ios.precision(60);
   22033             {
   22034                 nouppercase(ios);
   22035                 {
   22036                     noshowpos(ios);
   22037                     {
   22038                         noshowpoint(ios);
   22039                         {
   22040                             ios.imbue(lc);
   22041                             {
   22042                                 ios.width(0);
   22043                                 {
   22044                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22045                                     std::string ex(str, iter.base());
   22046                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
   22047                                     assert(ios.width() == 0);
   22048                                 }
   22049                                 ios.width(25);
   22050                                 left(ios);
   22051                                 {
   22052                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22053                                     std::string ex(str, iter.base());
   22054                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
   22055                                     assert(ios.width() == 0);
   22056                                 }
   22057                                 ios.width(25);
   22058                                 right(ios);
   22059                                 {
   22060                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22061                                     std::string ex(str, iter.base());
   22062                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
   22063                                     assert(ios.width() == 0);
   22064                                 }
   22065                                 ios.width(25);
   22066                                 internal(ios);
   22067                                 {
   22068                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22069                                     std::string ex(str, iter.base());
   22070                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
   22071                                     assert(ios.width() == 0);
   22072                                 }
   22073                             }
   22074                             ios.imbue(lg);
   22075                             {
   22076                                 ios.width(0);
   22077                                 {
   22078                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22079                                     std::string ex(str, iter.base());
   22080                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
   22081                                     assert(ios.width() == 0);
   22082                                 }
   22083                                 ios.width(25);
   22084                                 left(ios);
   22085                                 {
   22086                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22087                                     std::string ex(str, iter.base());
   22088                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
   22089                                     assert(ios.width() == 0);
   22090                                 }
   22091                                 ios.width(25);
   22092                                 right(ios);
   22093                                 {
   22094                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22095                                     std::string ex(str, iter.base());
   22096                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
   22097                                     assert(ios.width() == 0);
   22098                                 }
   22099                                 ios.width(25);
   22100                                 internal(ios);
   22101                                 {
   22102                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22103                                     std::string ex(str, iter.base());
   22104                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
   22105                                     assert(ios.width() == 0);
   22106                                 }
   22107                             }
   22108                         }
   22109                         showpoint(ios);
   22110                         {
   22111                             ios.imbue(lc);
   22112                             {
   22113                                 ios.width(0);
   22114                                 {
   22115                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22116                                     std::string ex(str, iter.base());
   22117                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
   22118                                     assert(ios.width() == 0);
   22119                                 }
   22120                                 ios.width(25);
   22121                                 left(ios);
   22122                                 {
   22123                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22124                                     std::string ex(str, iter.base());
   22125                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
   22126                                     assert(ios.width() == 0);
   22127                                 }
   22128                                 ios.width(25);
   22129                                 right(ios);
   22130                                 {
   22131                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22132                                     std::string ex(str, iter.base());
   22133                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
   22134                                     assert(ios.width() == 0);
   22135                                 }
   22136                                 ios.width(25);
   22137                                 internal(ios);
   22138                                 {
   22139                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22140                                     std::string ex(str, iter.base());
   22141                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
   22142                                     assert(ios.width() == 0);
   22143                                 }
   22144                             }
   22145                             ios.imbue(lg);
   22146                             {
   22147                                 ios.width(0);
   22148                                 {
   22149                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22150                                     std::string ex(str, iter.base());
   22151                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
   22152                                     assert(ios.width() == 0);
   22153                                 }
   22154                                 ios.width(25);
   22155                                 left(ios);
   22156                                 {
   22157                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22158                                     std::string ex(str, iter.base());
   22159                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
   22160                                     assert(ios.width() == 0);
   22161                                 }
   22162                                 ios.width(25);
   22163                                 right(ios);
   22164                                 {
   22165                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22166                                     std::string ex(str, iter.base());
   22167                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
   22168                                     assert(ios.width() == 0);
   22169                                 }
   22170                                 ios.width(25);
   22171                                 internal(ios);
   22172                                 {
   22173                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22174                                     std::string ex(str, iter.base());
   22175                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
   22176                                     assert(ios.width() == 0);
   22177                                 }
   22178                             }
   22179                         }
   22180                     }
   22181                     showpos(ios);
   22182                     {
   22183                         noshowpoint(ios);
   22184                         {
   22185                             ios.imbue(lc);
   22186                             {
   22187                                 ios.width(0);
   22188                                 {
   22189                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22190                                     std::string ex(str, iter.base());
   22191                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
   22192                                     assert(ios.width() == 0);
   22193                                 }
   22194                                 ios.width(25);
   22195                                 left(ios);
   22196                                 {
   22197                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22198                                     std::string ex(str, iter.base());
   22199                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
   22200                                     assert(ios.width() == 0);
   22201                                 }
   22202                                 ios.width(25);
   22203                                 right(ios);
   22204                                 {
   22205                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22206                                     std::string ex(str, iter.base());
   22207                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
   22208                                     assert(ios.width() == 0);
   22209                                 }
   22210                                 ios.width(25);
   22211                                 internal(ios);
   22212                                 {
   22213                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22214                                     std::string ex(str, iter.base());
   22215                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
   22216                                     assert(ios.width() == 0);
   22217                                 }
   22218                             }
   22219                             ios.imbue(lg);
   22220                             {
   22221                                 ios.width(0);
   22222                                 {
   22223                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22224                                     std::string ex(str, iter.base());
   22225                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
   22226                                     assert(ios.width() == 0);
   22227                                 }
   22228                                 ios.width(25);
   22229                                 left(ios);
   22230                                 {
   22231                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22232                                     std::string ex(str, iter.base());
   22233                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
   22234                                     assert(ios.width() == 0);
   22235                                 }
   22236                                 ios.width(25);
   22237                                 right(ios);
   22238                                 {
   22239                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22240                                     std::string ex(str, iter.base());
   22241                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
   22242                                     assert(ios.width() == 0);
   22243                                 }
   22244                                 ios.width(25);
   22245                                 internal(ios);
   22246                                 {
   22247                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22248                                     std::string ex(str, iter.base());
   22249                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
   22250                                     assert(ios.width() == 0);
   22251                                 }
   22252                             }
   22253                         }
   22254                         showpoint(ios);
   22255                         {
   22256                             ios.imbue(lc);
   22257                             {
   22258                                 ios.width(0);
   22259                                 {
   22260                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22261                                     std::string ex(str, iter.base());
   22262                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
   22263                                     assert(ios.width() == 0);
   22264                                 }
   22265                                 ios.width(25);
   22266                                 left(ios);
   22267                                 {
   22268                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22269                                     std::string ex(str, iter.base());
   22270                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
   22271                                     assert(ios.width() == 0);
   22272                                 }
   22273                                 ios.width(25);
   22274                                 right(ios);
   22275                                 {
   22276                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22277                                     std::string ex(str, iter.base());
   22278                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
   22279                                     assert(ios.width() == 0);
   22280                                 }
   22281                                 ios.width(25);
   22282                                 internal(ios);
   22283                                 {
   22284                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22285                                     std::string ex(str, iter.base());
   22286                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
   22287                                     assert(ios.width() == 0);
   22288                                 }
   22289                             }
   22290                             ios.imbue(lg);
   22291                             {
   22292                                 ios.width(0);
   22293                                 {
   22294                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22295                                     std::string ex(str, iter.base());
   22296                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
   22297                                     assert(ios.width() == 0);
   22298                                 }
   22299                                 ios.width(25);
   22300                                 left(ios);
   22301                                 {
   22302                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22303                                     std::string ex(str, iter.base());
   22304                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
   22305                                     assert(ios.width() == 0);
   22306                                 }
   22307                                 ios.width(25);
   22308                                 right(ios);
   22309                                 {
   22310                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22311                                     std::string ex(str, iter.base());
   22312                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
   22313                                     assert(ios.width() == 0);
   22314                                 }
   22315                                 ios.width(25);
   22316                                 internal(ios);
   22317                                 {
   22318                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22319                                     std::string ex(str, iter.base());
   22320                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
   22321                                     assert(ios.width() == 0);
   22322                                 }
   22323                             }
   22324                         }
   22325                     }
   22326                 }
   22327                 uppercase(ios);
   22328                 {
   22329                     noshowpos(ios);
   22330                     {
   22331                         noshowpoint(ios);
   22332                         {
   22333                             ios.imbue(lc);
   22334                             {
   22335                                 ios.width(0);
   22336                                 {
   22337                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22338                                     std::string ex(str, iter.base());
   22339                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
   22340                                     assert(ios.width() == 0);
   22341                                 }
   22342                                 ios.width(25);
   22343                                 left(ios);
   22344                                 {
   22345                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22346                                     std::string ex(str, iter.base());
   22347                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
   22348                                     assert(ios.width() == 0);
   22349                                 }
   22350                                 ios.width(25);
   22351                                 right(ios);
   22352                                 {
   22353                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22354                                     std::string ex(str, iter.base());
   22355                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
   22356                                     assert(ios.width() == 0);
   22357                                 }
   22358                                 ios.width(25);
   22359                                 internal(ios);
   22360                                 {
   22361                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22362                                     std::string ex(str, iter.base());
   22363                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
   22364                                     assert(ios.width() == 0);
   22365                                 }
   22366                             }
   22367                             ios.imbue(lg);
   22368                             {
   22369                                 ios.width(0);
   22370                                 {
   22371                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22372                                     std::string ex(str, iter.base());
   22373                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
   22374                                     assert(ios.width() == 0);
   22375                                 }
   22376                                 ios.width(25);
   22377                                 left(ios);
   22378                                 {
   22379                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22380                                     std::string ex(str, iter.base());
   22381                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
   22382                                     assert(ios.width() == 0);
   22383                                 }
   22384                                 ios.width(25);
   22385                                 right(ios);
   22386                                 {
   22387                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22388                                     std::string ex(str, iter.base());
   22389                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
   22390                                     assert(ios.width() == 0);
   22391                                 }
   22392                                 ios.width(25);
   22393                                 internal(ios);
   22394                                 {
   22395                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22396                                     std::string ex(str, iter.base());
   22397                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
   22398                                     assert(ios.width() == 0);
   22399                                 }
   22400                             }
   22401                         }
   22402                         showpoint(ios);
   22403                         {
   22404                             ios.imbue(lc);
   22405                             {
   22406                                 ios.width(0);
   22407                                 {
   22408                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22409                                     std::string ex(str, iter.base());
   22410                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
   22411                                     assert(ios.width() == 0);
   22412                                 }
   22413                                 ios.width(25);
   22414                                 left(ios);
   22415                                 {
   22416                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22417                                     std::string ex(str, iter.base());
   22418                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
   22419                                     assert(ios.width() == 0);
   22420                                 }
   22421                                 ios.width(25);
   22422                                 right(ios);
   22423                                 {
   22424                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22425                                     std::string ex(str, iter.base());
   22426                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
   22427                                     assert(ios.width() == 0);
   22428                                 }
   22429                                 ios.width(25);
   22430                                 internal(ios);
   22431                                 {
   22432                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22433                                     std::string ex(str, iter.base());
   22434                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
   22435                                     assert(ios.width() == 0);
   22436                                 }
   22437                             }
   22438                             ios.imbue(lg);
   22439                             {
   22440                                 ios.width(0);
   22441                                 {
   22442                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22443                                     std::string ex(str, iter.base());
   22444                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
   22445                                     assert(ios.width() == 0);
   22446                                 }
   22447                                 ios.width(25);
   22448                                 left(ios);
   22449                                 {
   22450                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22451                                     std::string ex(str, iter.base());
   22452                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
   22453                                     assert(ios.width() == 0);
   22454                                 }
   22455                                 ios.width(25);
   22456                                 right(ios);
   22457                                 {
   22458                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22459                                     std::string ex(str, iter.base());
   22460                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
   22461                                     assert(ios.width() == 0);
   22462                                 }
   22463                                 ios.width(25);
   22464                                 internal(ios);
   22465                                 {
   22466                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22467                                     std::string ex(str, iter.base());
   22468                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
   22469                                     assert(ios.width() == 0);
   22470                                 }
   22471                             }
   22472                         }
   22473                     }
   22474                     showpos(ios);
   22475                     {
   22476                         noshowpoint(ios);
   22477                         {
   22478                             ios.imbue(lc);
   22479                             {
   22480                                 ios.width(0);
   22481                                 {
   22482                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22483                                     std::string ex(str, iter.base());
   22484                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
   22485                                     assert(ios.width() == 0);
   22486                                 }
   22487                                 ios.width(25);
   22488                                 left(ios);
   22489                                 {
   22490                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22491                                     std::string ex(str, iter.base());
   22492                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
   22493                                     assert(ios.width() == 0);
   22494                                 }
   22495                                 ios.width(25);
   22496                                 right(ios);
   22497                                 {
   22498                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22499                                     std::string ex(str, iter.base());
   22500                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
   22501                                     assert(ios.width() == 0);
   22502                                 }
   22503                                 ios.width(25);
   22504                                 internal(ios);
   22505                                 {
   22506                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22507                                     std::string ex(str, iter.base());
   22508                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
   22509                                     assert(ios.width() == 0);
   22510                                 }
   22511                             }
   22512                             ios.imbue(lg);
   22513                             {
   22514                                 ios.width(0);
   22515                                 {
   22516                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22517                                     std::string ex(str, iter.base());
   22518                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
   22519                                     assert(ios.width() == 0);
   22520                                 }
   22521                                 ios.width(25);
   22522                                 left(ios);
   22523                                 {
   22524                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22525                                     std::string ex(str, iter.base());
   22526                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
   22527                                     assert(ios.width() == 0);
   22528                                 }
   22529                                 ios.width(25);
   22530                                 right(ios);
   22531                                 {
   22532                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22533                                     std::string ex(str, iter.base());
   22534                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
   22535                                     assert(ios.width() == 0);
   22536                                 }
   22537                                 ios.width(25);
   22538                                 internal(ios);
   22539                                 {
   22540                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22541                                     std::string ex(str, iter.base());
   22542                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
   22543                                     assert(ios.width() == 0);
   22544                                 }
   22545                             }
   22546                         }
   22547                         showpoint(ios);
   22548                         {
   22549                             ios.imbue(lc);
   22550                             {
   22551                                 ios.width(0);
   22552                                 {
   22553                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22554                                     std::string ex(str, iter.base());
   22555                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
   22556                                     assert(ios.width() == 0);
   22557                                 }
   22558                                 ios.width(25);
   22559                                 left(ios);
   22560                                 {
   22561                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22562                                     std::string ex(str, iter.base());
   22563                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
   22564                                     assert(ios.width() == 0);
   22565                                 }
   22566                                 ios.width(25);
   22567                                 right(ios);
   22568                                 {
   22569                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22570                                     std::string ex(str, iter.base());
   22571                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
   22572                                     assert(ios.width() == 0);
   22573                                 }
   22574                                 ios.width(25);
   22575                                 internal(ios);
   22576                                 {
   22577                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22578                                     std::string ex(str, iter.base());
   22579                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
   22580                                     assert(ios.width() == 0);
   22581                                 }
   22582                             }
   22583                             ios.imbue(lg);
   22584                             {
   22585                                 ios.width(0);
   22586                                 {
   22587                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22588                                     std::string ex(str, iter.base());
   22589                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
   22590                                     assert(ios.width() == 0);
   22591                                 }
   22592                                 ios.width(25);
   22593                                 left(ios);
   22594                                 {
   22595                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22596                                     std::string ex(str, iter.base());
   22597                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
   22598                                     assert(ios.width() == 0);
   22599                                 }
   22600                                 ios.width(25);
   22601                                 right(ios);
   22602                                 {
   22603                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22604                                     std::string ex(str, iter.base());
   22605                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
   22606                                     assert(ios.width() == 0);
   22607                                 }
   22608                                 ios.width(25);
   22609                                 internal(ios);
   22610                                 {
   22611                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22612                                     std::string ex(str, iter.base());
   22613                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
   22614                                     assert(ios.width() == 0);
   22615                                 }
   22616                             }
   22617                         }
   22618                     }
   22619                 }
   22620             }
   22621         }
   22622     }
   22623 }
   22624 
   22625 void test11()
   22626 {
   22627     char str[200];
   22628     output_iterator<char*> iter;
   22629     std::locale lc = std::locale::classic();
   22630     std::locale lg(lc, new my_numpunct);
   22631     const my_facet f(1);
   22632     {
   22633         long double v = -0.;
   22634         std::ios ios(0);
   22635         hexfloat(ios);
   22636         // %a
   22637         {
   22638             ios.precision(0);
   22639             {
   22640                 nouppercase(ios);
   22641                 {
   22642                     noshowpos(ios);
   22643                     {
   22644                         noshowpoint(ios);
   22645                         {
   22646                             ios.imbue(lc);
   22647                             {
   22648                                 ios.width(0);
   22649                                 {
   22650                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22651                                     std::string ex(str, iter.base());
   22652                                     assert(ex == "-0x0p+0");
   22653                                     assert(ios.width() == 0);
   22654                                 }
   22655                                 ios.width(25);
   22656                                 left(ios);
   22657                                 {
   22658                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22659                                     std::string ex(str, iter.base());
   22660                                     assert(ex == "-0x0p+0******************");
   22661                                     assert(ios.width() == 0);
   22662                                 }
   22663                                 ios.width(25);
   22664                                 right(ios);
   22665                                 {
   22666                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22667                                     std::string ex(str, iter.base());
   22668                                     assert(ex == "******************-0x0p+0");
   22669                                     assert(ios.width() == 0);
   22670                                 }
   22671                                 ios.width(25);
   22672                                 internal(ios);
   22673                                 {
   22674                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22675                                     std::string ex(str, iter.base());
   22676                                     assert(ex == "-******************0x0p+0");
   22677                                     assert(ios.width() == 0);
   22678                                 }
   22679                             }
   22680                             ios.imbue(lg);
   22681                             {
   22682                                 ios.width(0);
   22683                                 {
   22684                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22685                                     std::string ex(str, iter.base());
   22686                                     assert(ex == "-0x0p+0");
   22687                                     assert(ios.width() == 0);
   22688                                 }
   22689                                 ios.width(25);
   22690                                 left(ios);
   22691                                 {
   22692                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22693                                     std::string ex(str, iter.base());
   22694                                     assert(ex == "-0x0p+0******************");
   22695                                     assert(ios.width() == 0);
   22696                                 }
   22697                                 ios.width(25);
   22698                                 right(ios);
   22699                                 {
   22700                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22701                                     std::string ex(str, iter.base());
   22702                                     assert(ex == "******************-0x0p+0");
   22703                                     assert(ios.width() == 0);
   22704                                 }
   22705                                 ios.width(25);
   22706                                 internal(ios);
   22707                                 {
   22708                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22709                                     std::string ex(str, iter.base());
   22710                                     assert(ex == "-******************0x0p+0");
   22711                                     assert(ios.width() == 0);
   22712                                 }
   22713                             }
   22714                         }
   22715                         showpoint(ios);
   22716                         {
   22717                             ios.imbue(lc);
   22718                             {
   22719                                 ios.width(0);
   22720                                 {
   22721                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22722                                     std::string ex(str, iter.base());
   22723                                     assert(ex == "-0x0.p+0");
   22724                                     assert(ios.width() == 0);
   22725                                 }
   22726                                 ios.width(25);
   22727                                 left(ios);
   22728                                 {
   22729                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22730                                     std::string ex(str, iter.base());
   22731                                     assert(ex == "-0x0.p+0*****************");
   22732                                     assert(ios.width() == 0);
   22733                                 }
   22734                                 ios.width(25);
   22735                                 right(ios);
   22736                                 {
   22737                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22738                                     std::string ex(str, iter.base());
   22739                                     assert(ex == "*****************-0x0.p+0");
   22740                                     assert(ios.width() == 0);
   22741                                 }
   22742                                 ios.width(25);
   22743                                 internal(ios);
   22744                                 {
   22745                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22746                                     std::string ex(str, iter.base());
   22747                                     assert(ex == "-*****************0x0.p+0");
   22748                                     assert(ios.width() == 0);
   22749                                 }
   22750                             }
   22751                             ios.imbue(lg);
   22752                             {
   22753                                 ios.width(0);
   22754                                 {
   22755                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22756                                     std::string ex(str, iter.base());
   22757                                     assert(ex == "-0x0;p+0");
   22758                                     assert(ios.width() == 0);
   22759                                 }
   22760                                 ios.width(25);
   22761                                 left(ios);
   22762                                 {
   22763                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22764                                     std::string ex(str, iter.base());
   22765                                     assert(ex == "-0x0;p+0*****************");
   22766                                     assert(ios.width() == 0);
   22767                                 }
   22768                                 ios.width(25);
   22769                                 right(ios);
   22770                                 {
   22771                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22772                                     std::string ex(str, iter.base());
   22773                                     assert(ex == "*****************-0x0;p+0");
   22774                                     assert(ios.width() == 0);
   22775                                 }
   22776                                 ios.width(25);
   22777                                 internal(ios);
   22778                                 {
   22779                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22780                                     std::string ex(str, iter.base());
   22781                                     assert(ex == "-*****************0x0;p+0");
   22782                                     assert(ios.width() == 0);
   22783                                 }
   22784                             }
   22785                         }
   22786                     }
   22787                     showpos(ios);
   22788                     {
   22789                         noshowpoint(ios);
   22790                         {
   22791                             ios.imbue(lc);
   22792                             {
   22793                                 ios.width(0);
   22794                                 {
   22795                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22796                                     std::string ex(str, iter.base());
   22797                                     assert(ex == "-0x0p+0");
   22798                                     assert(ios.width() == 0);
   22799                                 }
   22800                                 ios.width(25);
   22801                                 left(ios);
   22802                                 {
   22803                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22804                                     std::string ex(str, iter.base());
   22805                                     assert(ex == "-0x0p+0******************");
   22806                                     assert(ios.width() == 0);
   22807                                 }
   22808                                 ios.width(25);
   22809                                 right(ios);
   22810                                 {
   22811                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22812                                     std::string ex(str, iter.base());
   22813                                     assert(ex == "******************-0x0p+0");
   22814                                     assert(ios.width() == 0);
   22815                                 }
   22816                                 ios.width(25);
   22817                                 internal(ios);
   22818                                 {
   22819                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22820                                     std::string ex(str, iter.base());
   22821                                     assert(ex == "-******************0x0p+0");
   22822                                     assert(ios.width() == 0);
   22823                                 }
   22824                             }
   22825                             ios.imbue(lg);
   22826                             {
   22827                                 ios.width(0);
   22828                                 {
   22829                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22830                                     std::string ex(str, iter.base());
   22831                                     assert(ex == "-0x0p+0");
   22832                                     assert(ios.width() == 0);
   22833                                 }
   22834                                 ios.width(25);
   22835                                 left(ios);
   22836                                 {
   22837                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22838                                     std::string ex(str, iter.base());
   22839                                     assert(ex == "-0x0p+0******************");
   22840                                     assert(ios.width() == 0);
   22841                                 }
   22842                                 ios.width(25);
   22843                                 right(ios);
   22844                                 {
   22845                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22846                                     std::string ex(str, iter.base());
   22847                                     assert(ex == "******************-0x0p+0");
   22848                                     assert(ios.width() == 0);
   22849                                 }
   22850                                 ios.width(25);
   22851                                 internal(ios);
   22852                                 {
   22853                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22854                                     std::string ex(str, iter.base());
   22855                                     assert(ex == "-******************0x0p+0");
   22856                                     assert(ios.width() == 0);
   22857                                 }
   22858                             }
   22859                         }
   22860                         showpoint(ios);
   22861                         {
   22862                             ios.imbue(lc);
   22863                             {
   22864                                 ios.width(0);
   22865                                 {
   22866                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22867                                     std::string ex(str, iter.base());
   22868                                     assert(ex == "-0x0.p+0");
   22869                                     assert(ios.width() == 0);
   22870                                 }
   22871                                 ios.width(25);
   22872                                 left(ios);
   22873                                 {
   22874                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22875                                     std::string ex(str, iter.base());
   22876                                     assert(ex == "-0x0.p+0*****************");
   22877                                     assert(ios.width() == 0);
   22878                                 }
   22879                                 ios.width(25);
   22880                                 right(ios);
   22881                                 {
   22882                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22883                                     std::string ex(str, iter.base());
   22884                                     assert(ex == "*****************-0x0.p+0");
   22885                                     assert(ios.width() == 0);
   22886                                 }
   22887                                 ios.width(25);
   22888                                 internal(ios);
   22889                                 {
   22890                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22891                                     std::string ex(str, iter.base());
   22892                                     assert(ex == "-*****************0x0.p+0");
   22893                                     assert(ios.width() == 0);
   22894                                 }
   22895                             }
   22896                             ios.imbue(lg);
   22897                             {
   22898                                 ios.width(0);
   22899                                 {
   22900                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22901                                     std::string ex(str, iter.base());
   22902                                     assert(ex == "-0x0;p+0");
   22903                                     assert(ios.width() == 0);
   22904                                 }
   22905                                 ios.width(25);
   22906                                 left(ios);
   22907                                 {
   22908                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22909                                     std::string ex(str, iter.base());
   22910                                     assert(ex == "-0x0;p+0*****************");
   22911                                     assert(ios.width() == 0);
   22912                                 }
   22913                                 ios.width(25);
   22914                                 right(ios);
   22915                                 {
   22916                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22917                                     std::string ex(str, iter.base());
   22918                                     assert(ex == "*****************-0x0;p+0");
   22919                                     assert(ios.width() == 0);
   22920                                 }
   22921                                 ios.width(25);
   22922                                 internal(ios);
   22923                                 {
   22924                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22925                                     std::string ex(str, iter.base());
   22926                                     assert(ex == "-*****************0x0;p+0");
   22927                                     assert(ios.width() == 0);
   22928                                 }
   22929                             }
   22930                         }
   22931                     }
   22932                 }
   22933                 uppercase(ios);
   22934                 {
   22935                     noshowpos(ios);
   22936                     {
   22937                         noshowpoint(ios);
   22938                         {
   22939                             ios.imbue(lc);
   22940                             {
   22941                                 ios.width(0);
   22942                                 {
   22943                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22944                                     std::string ex(str, iter.base());
   22945                                     assert(ex == "-0X0P+0");
   22946                                     assert(ios.width() == 0);
   22947                                 }
   22948                                 ios.width(25);
   22949                                 left(ios);
   22950                                 {
   22951                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22952                                     std::string ex(str, iter.base());
   22953                                     assert(ex == "-0X0P+0******************");
   22954                                     assert(ios.width() == 0);
   22955                                 }
   22956                                 ios.width(25);
   22957                                 right(ios);
   22958                                 {
   22959                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22960                                     std::string ex(str, iter.base());
   22961                                     assert(ex == "******************-0X0P+0");
   22962                                     assert(ios.width() == 0);
   22963                                 }
   22964                                 ios.width(25);
   22965                                 internal(ios);
   22966                                 {
   22967                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22968                                     std::string ex(str, iter.base());
   22969                                     assert(ex == "-******************0X0P+0");
   22970                                     assert(ios.width() == 0);
   22971                                 }
   22972                             }
   22973                             ios.imbue(lg);
   22974                             {
   22975                                 ios.width(0);
   22976                                 {
   22977                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22978                                     std::string ex(str, iter.base());
   22979                                     assert(ex == "-0X0P+0");
   22980                                     assert(ios.width() == 0);
   22981                                 }
   22982                                 ios.width(25);
   22983                                 left(ios);
   22984                                 {
   22985                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22986                                     std::string ex(str, iter.base());
   22987                                     assert(ex == "-0X0P+0******************");
   22988                                     assert(ios.width() == 0);
   22989                                 }
   22990                                 ios.width(25);
   22991                                 right(ios);
   22992                                 {
   22993                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22994                                     std::string ex(str, iter.base());
   22995                                     assert(ex == "******************-0X0P+0");
   22996                                     assert(ios.width() == 0);
   22997                                 }
   22998                                 ios.width(25);
   22999                                 internal(ios);
   23000                                 {
   23001                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23002                                     std::string ex(str, iter.base());
   23003                                     assert(ex == "-******************0X0P+0");
   23004                                     assert(ios.width() == 0);
   23005                                 }
   23006                             }
   23007                         }
   23008                         showpoint(ios);
   23009                         {
   23010                             ios.imbue(lc);
   23011                             {
   23012                                 ios.width(0);
   23013                                 {
   23014                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23015                                     std::string ex(str, iter.base());
   23016                                     assert(ex == "-0X0.P+0");
   23017                                     assert(ios.width() == 0);
   23018                                 }
   23019                                 ios.width(25);
   23020                                 left(ios);
   23021                                 {
   23022                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23023                                     std::string ex(str, iter.base());
   23024                                     assert(ex == "-0X0.P+0*****************");
   23025                                     assert(ios.width() == 0);
   23026                                 }
   23027                                 ios.width(25);
   23028                                 right(ios);
   23029                                 {
   23030                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23031                                     std::string ex(str, iter.base());
   23032                                     assert(ex == "*****************-0X0.P+0");
   23033                                     assert(ios.width() == 0);
   23034                                 }
   23035                                 ios.width(25);
   23036                                 internal(ios);
   23037                                 {
   23038                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23039                                     std::string ex(str, iter.base());
   23040                                     assert(ex == "-*****************0X0.P+0");
   23041                                     assert(ios.width() == 0);
   23042                                 }
   23043                             }
   23044                             ios.imbue(lg);
   23045                             {
   23046                                 ios.width(0);
   23047                                 {
   23048                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23049                                     std::string ex(str, iter.base());
   23050                                     assert(ex == "-0X0;P+0");
   23051                                     assert(ios.width() == 0);
   23052                                 }
   23053                                 ios.width(25);
   23054                                 left(ios);
   23055                                 {
   23056                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23057                                     std::string ex(str, iter.base());
   23058                                     assert(ex == "-0X0;P+0*****************");
   23059                                     assert(ios.width() == 0);
   23060                                 }
   23061                                 ios.width(25);
   23062                                 right(ios);
   23063                                 {
   23064                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23065                                     std::string ex(str, iter.base());
   23066                                     assert(ex == "*****************-0X0;P+0");
   23067                                     assert(ios.width() == 0);
   23068                                 }
   23069                                 ios.width(25);
   23070                                 internal(ios);
   23071                                 {
   23072                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23073                                     std::string ex(str, iter.base());
   23074                                     assert(ex == "-*****************0X0;P+0");
   23075                                     assert(ios.width() == 0);
   23076                                 }
   23077                             }
   23078                         }
   23079                     }
   23080                     showpos(ios);
   23081                     {
   23082                         noshowpoint(ios);
   23083                         {
   23084                             ios.imbue(lc);
   23085                             {
   23086                                 ios.width(0);
   23087                                 {
   23088                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23089                                     std::string ex(str, iter.base());
   23090                                     assert(ex == "-0X0P+0");
   23091                                     assert(ios.width() == 0);
   23092                                 }
   23093                                 ios.width(25);
   23094                                 left(ios);
   23095                                 {
   23096                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23097                                     std::string ex(str, iter.base());
   23098                                     assert(ex == "-0X0P+0******************");
   23099                                     assert(ios.width() == 0);
   23100                                 }
   23101                                 ios.width(25);
   23102                                 right(ios);
   23103                                 {
   23104                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23105                                     std::string ex(str, iter.base());
   23106                                     assert(ex == "******************-0X0P+0");
   23107                                     assert(ios.width() == 0);
   23108                                 }
   23109                                 ios.width(25);
   23110                                 internal(ios);
   23111                                 {
   23112                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23113                                     std::string ex(str, iter.base());
   23114                                     assert(ex == "-******************0X0P+0");
   23115                                     assert(ios.width() == 0);
   23116                                 }
   23117                             }
   23118                             ios.imbue(lg);
   23119                             {
   23120                                 ios.width(0);
   23121                                 {
   23122                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23123                                     std::string ex(str, iter.base());
   23124                                     assert(ex == "-0X0P+0");
   23125                                     assert(ios.width() == 0);
   23126                                 }
   23127                                 ios.width(25);
   23128                                 left(ios);
   23129                                 {
   23130                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23131                                     std::string ex(str, iter.base());
   23132                                     assert(ex == "-0X0P+0******************");
   23133                                     assert(ios.width() == 0);
   23134                                 }
   23135                                 ios.width(25);
   23136                                 right(ios);
   23137                                 {
   23138                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23139                                     std::string ex(str, iter.base());
   23140                                     assert(ex == "******************-0X0P+0");
   23141                                     assert(ios.width() == 0);
   23142                                 }
   23143                                 ios.width(25);
   23144                                 internal(ios);
   23145                                 {
   23146                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23147                                     std::string ex(str, iter.base());
   23148                                     assert(ex == "-******************0X0P+0");
   23149                                     assert(ios.width() == 0);
   23150                                 }
   23151                             }
   23152                         }
   23153                         showpoint(ios);
   23154                         {
   23155                             ios.imbue(lc);
   23156                             {
   23157                                 ios.width(0);
   23158                                 {
   23159                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23160                                     std::string ex(str, iter.base());
   23161                                     assert(ex == "-0X0.P+0");
   23162                                     assert(ios.width() == 0);
   23163                                 }
   23164                                 ios.width(25);
   23165                                 left(ios);
   23166                                 {
   23167                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23168                                     std::string ex(str, iter.base());
   23169                                     assert(ex == "-0X0.P+0*****************");
   23170                                     assert(ios.width() == 0);
   23171                                 }
   23172                                 ios.width(25);
   23173                                 right(ios);
   23174                                 {
   23175                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23176                                     std::string ex(str, iter.base());
   23177                                     assert(ex == "*****************-0X0.P+0");
   23178                                     assert(ios.width() == 0);
   23179                                 }
   23180                                 ios.width(25);
   23181                                 internal(ios);
   23182                                 {
   23183                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23184                                     std::string ex(str, iter.base());
   23185                                     assert(ex == "-*****************0X0.P+0");
   23186                                     assert(ios.width() == 0);
   23187                                 }
   23188                             }
   23189                             ios.imbue(lg);
   23190                             {
   23191                                 ios.width(0);
   23192                                 {
   23193                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23194                                     std::string ex(str, iter.base());
   23195                                     assert(ex == "-0X0;P+0");
   23196                                     assert(ios.width() == 0);
   23197                                 }
   23198                                 ios.width(25);
   23199                                 left(ios);
   23200                                 {
   23201                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23202                                     std::string ex(str, iter.base());
   23203                                     assert(ex == "-0X0;P+0*****************");
   23204                                     assert(ios.width() == 0);
   23205                                 }
   23206                                 ios.width(25);
   23207                                 right(ios);
   23208                                 {
   23209                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23210                                     std::string ex(str, iter.base());
   23211                                     assert(ex == "*****************-0X0;P+0");
   23212                                     assert(ios.width() == 0);
   23213                                 }
   23214                                 ios.width(25);
   23215                                 internal(ios);
   23216                                 {
   23217                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23218                                     std::string ex(str, iter.base());
   23219                                     assert(ex == "-*****************0X0;P+0");
   23220                                     assert(ios.width() == 0);
   23221                                 }
   23222                             }
   23223                         }
   23224                     }
   23225                 }
   23226             }
   23227             ios.precision(1);
   23228             {
   23229                 nouppercase(ios);
   23230                 {
   23231                     noshowpos(ios);
   23232                     {
   23233                         noshowpoint(ios);
   23234                         {
   23235                             ios.imbue(lc);
   23236                             {
   23237                                 ios.width(0);
   23238                                 {
   23239                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23240                                     std::string ex(str, iter.base());
   23241                                     assert(ex == "-0x0p+0");
   23242                                     assert(ios.width() == 0);
   23243                                 }
   23244                                 ios.width(25);
   23245                                 left(ios);
   23246                                 {
   23247                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23248                                     std::string ex(str, iter.base());
   23249                                     assert(ex == "-0x0p+0******************");
   23250                                     assert(ios.width() == 0);
   23251                                 }
   23252                                 ios.width(25);
   23253                                 right(ios);
   23254                                 {
   23255                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23256                                     std::string ex(str, iter.base());
   23257                                     assert(ex == "******************-0x0p+0");
   23258                                     assert(ios.width() == 0);
   23259                                 }
   23260                                 ios.width(25);
   23261                                 internal(ios);
   23262                                 {
   23263                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23264                                     std::string ex(str, iter.base());
   23265                                     assert(ex == "-******************0x0p+0");
   23266                                     assert(ios.width() == 0);
   23267                                 }
   23268                             }
   23269                             ios.imbue(lg);
   23270                             {
   23271                                 ios.width(0);
   23272                                 {
   23273                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23274                                     std::string ex(str, iter.base());
   23275                                     assert(ex == "-0x0p+0");
   23276                                     assert(ios.width() == 0);
   23277                                 }
   23278                                 ios.width(25);
   23279                                 left(ios);
   23280                                 {
   23281                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23282                                     std::string ex(str, iter.base());
   23283                                     assert(ex == "-0x0p+0******************");
   23284                                     assert(ios.width() == 0);
   23285                                 }
   23286                                 ios.width(25);
   23287                                 right(ios);
   23288                                 {
   23289                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23290                                     std::string ex(str, iter.base());
   23291                                     assert(ex == "******************-0x0p+0");
   23292                                     assert(ios.width() == 0);
   23293                                 }
   23294                                 ios.width(25);
   23295                                 internal(ios);
   23296                                 {
   23297                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23298                                     std::string ex(str, iter.base());
   23299                                     assert(ex == "-******************0x0p+0");
   23300                                     assert(ios.width() == 0);
   23301                                 }
   23302                             }
   23303                         }
   23304                         showpoint(ios);
   23305                         {
   23306                             ios.imbue(lc);
   23307                             {
   23308                                 ios.width(0);
   23309                                 {
   23310                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23311                                     std::string ex(str, iter.base());
   23312                                     assert(ex == "-0x0.p+0");
   23313                                     assert(ios.width() == 0);
   23314                                 }
   23315                                 ios.width(25);
   23316                                 left(ios);
   23317                                 {
   23318                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23319                                     std::string ex(str, iter.base());
   23320                                     assert(ex == "-0x0.p+0*****************");
   23321                                     assert(ios.width() == 0);
   23322                                 }
   23323                                 ios.width(25);
   23324                                 right(ios);
   23325                                 {
   23326                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23327                                     std::string ex(str, iter.base());
   23328                                     assert(ex == "*****************-0x0.p+0");
   23329                                     assert(ios.width() == 0);
   23330                                 }
   23331                                 ios.width(25);
   23332                                 internal(ios);
   23333                                 {
   23334                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23335                                     std::string ex(str, iter.base());
   23336                                     assert(ex == "-*****************0x0.p+0");
   23337                                     assert(ios.width() == 0);
   23338                                 }
   23339                             }
   23340                             ios.imbue(lg);
   23341                             {
   23342                                 ios.width(0);
   23343                                 {
   23344                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23345                                     std::string ex(str, iter.base());
   23346                                     assert(ex == "-0x0;p+0");
   23347                                     assert(ios.width() == 0);
   23348                                 }
   23349                                 ios.width(25);
   23350                                 left(ios);
   23351                                 {
   23352                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23353                                     std::string ex(str, iter.base());
   23354                                     assert(ex == "-0x0;p+0*****************");
   23355                                     assert(ios.width() == 0);
   23356                                 }
   23357                                 ios.width(25);
   23358                                 right(ios);
   23359                                 {
   23360                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23361                                     std::string ex(str, iter.base());
   23362                                     assert(ex == "*****************-0x0;p+0");
   23363                                     assert(ios.width() == 0);
   23364                                 }
   23365                                 ios.width(25);
   23366                                 internal(ios);
   23367                                 {
   23368                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23369                                     std::string ex(str, iter.base());
   23370                                     assert(ex == "-*****************0x0;p+0");
   23371                                     assert(ios.width() == 0);
   23372                                 }
   23373                             }
   23374                         }
   23375                     }
   23376                     showpos(ios);
   23377                     {
   23378                         noshowpoint(ios);
   23379                         {
   23380                             ios.imbue(lc);
   23381                             {
   23382                                 ios.width(0);
   23383                                 {
   23384                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23385                                     std::string ex(str, iter.base());
   23386                                     assert(ex == "-0x0p+0");
   23387                                     assert(ios.width() == 0);
   23388                                 }
   23389                                 ios.width(25);
   23390                                 left(ios);
   23391                                 {
   23392                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23393                                     std::string ex(str, iter.base());
   23394                                     assert(ex == "-0x0p+0******************");
   23395                                     assert(ios.width() == 0);
   23396                                 }
   23397                                 ios.width(25);
   23398                                 right(ios);
   23399                                 {
   23400                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23401                                     std::string ex(str, iter.base());
   23402                                     assert(ex == "******************-0x0p+0");
   23403                                     assert(ios.width() == 0);
   23404                                 }
   23405                                 ios.width(25);
   23406                                 internal(ios);
   23407                                 {
   23408                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23409                                     std::string ex(str, iter.base());
   23410                                     assert(ex == "-******************0x0p+0");
   23411                                     assert(ios.width() == 0);
   23412                                 }
   23413                             }
   23414                             ios.imbue(lg);
   23415                             {
   23416                                 ios.width(0);
   23417                                 {
   23418                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23419                                     std::string ex(str, iter.base());
   23420                                     assert(ex == "-0x0p+0");
   23421                                     assert(ios.width() == 0);
   23422                                 }
   23423                                 ios.width(25);
   23424                                 left(ios);
   23425                                 {
   23426                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23427                                     std::string ex(str, iter.base());
   23428                                     assert(ex == "-0x0p+0******************");
   23429                                     assert(ios.width() == 0);
   23430                                 }
   23431                                 ios.width(25);
   23432                                 right(ios);
   23433                                 {
   23434                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23435                                     std::string ex(str, iter.base());
   23436                                     assert(ex == "******************-0x0p+0");
   23437                                     assert(ios.width() == 0);
   23438                                 }
   23439                                 ios.width(25);
   23440                                 internal(ios);
   23441                                 {
   23442                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23443                                     std::string ex(str, iter.base());
   23444                                     assert(ex == "-******************0x0p+0");
   23445                                     assert(ios.width() == 0);
   23446                                 }
   23447                             }
   23448                         }
   23449                         showpoint(ios);
   23450                         {
   23451                             ios.imbue(lc);
   23452                             {
   23453                                 ios.width(0);
   23454                                 {
   23455                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23456                                     std::string ex(str, iter.base());
   23457                                     assert(ex == "-0x0.p+0");
   23458                                     assert(ios.width() == 0);
   23459                                 }
   23460                                 ios.width(25);
   23461                                 left(ios);
   23462                                 {
   23463                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23464                                     std::string ex(str, iter.base());
   23465                                     assert(ex == "-0x0.p+0*****************");
   23466                                     assert(ios.width() == 0);
   23467                                 }
   23468                                 ios.width(25);
   23469                                 right(ios);
   23470                                 {
   23471                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23472                                     std::string ex(str, iter.base());
   23473                                     assert(ex == "*****************-0x0.p+0");
   23474                                     assert(ios.width() == 0);
   23475                                 }
   23476                                 ios.width(25);
   23477                                 internal(ios);
   23478                                 {
   23479                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23480                                     std::string ex(str, iter.base());
   23481                                     assert(ex == "-*****************0x0.p+0");
   23482                                     assert(ios.width() == 0);
   23483                                 }
   23484                             }
   23485                             ios.imbue(lg);
   23486                             {
   23487                                 ios.width(0);
   23488                                 {
   23489                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23490                                     std::string ex(str, iter.base());
   23491                                     assert(ex == "-0x0;p+0");
   23492                                     assert(ios.width() == 0);
   23493                                 }
   23494                                 ios.width(25);
   23495                                 left(ios);
   23496                                 {
   23497                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23498                                     std::string ex(str, iter.base());
   23499                                     assert(ex == "-0x0;p+0*****************");
   23500                                     assert(ios.width() == 0);
   23501                                 }
   23502                                 ios.width(25);
   23503                                 right(ios);
   23504                                 {
   23505                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23506                                     std::string ex(str, iter.base());
   23507                                     assert(ex == "*****************-0x0;p+0");
   23508                                     assert(ios.width() == 0);
   23509                                 }
   23510                                 ios.width(25);
   23511                                 internal(ios);
   23512                                 {
   23513                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23514                                     std::string ex(str, iter.base());
   23515                                     assert(ex == "-*****************0x0;p+0");
   23516                                     assert(ios.width() == 0);
   23517                                 }
   23518                             }
   23519                         }
   23520                     }
   23521                 }
   23522                 uppercase(ios);
   23523                 {
   23524                     noshowpos(ios);
   23525                     {
   23526                         noshowpoint(ios);
   23527                         {
   23528                             ios.imbue(lc);
   23529                             {
   23530                                 ios.width(0);
   23531                                 {
   23532                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23533                                     std::string ex(str, iter.base());
   23534                                     assert(ex == "-0X0P+0");
   23535                                     assert(ios.width() == 0);
   23536                                 }
   23537                                 ios.width(25);
   23538                                 left(ios);
   23539                                 {
   23540                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23541                                     std::string ex(str, iter.base());
   23542                                     assert(ex == "-0X0P+0******************");
   23543                                     assert(ios.width() == 0);
   23544                                 }
   23545                                 ios.width(25);
   23546                                 right(ios);
   23547                                 {
   23548                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23549                                     std::string ex(str, iter.base());
   23550                                     assert(ex == "******************-0X0P+0");
   23551                                     assert(ios.width() == 0);
   23552                                 }
   23553                                 ios.width(25);
   23554                                 internal(ios);
   23555                                 {
   23556                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23557                                     std::string ex(str, iter.base());
   23558                                     assert(ex == "-******************0X0P+0");
   23559                                     assert(ios.width() == 0);
   23560                                 }
   23561                             }
   23562                             ios.imbue(lg);
   23563                             {
   23564                                 ios.width(0);
   23565                                 {
   23566                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23567                                     std::string ex(str, iter.base());
   23568                                     assert(ex == "-0X0P+0");
   23569                                     assert(ios.width() == 0);
   23570                                 }
   23571                                 ios.width(25);
   23572                                 left(ios);
   23573                                 {
   23574                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23575                                     std::string ex(str, iter.base());
   23576                                     assert(ex == "-0X0P+0******************");
   23577                                     assert(ios.width() == 0);
   23578                                 }
   23579                                 ios.width(25);
   23580                                 right(ios);
   23581                                 {
   23582                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23583                                     std::string ex(str, iter.base());
   23584                                     assert(ex == "******************-0X0P+0");
   23585                                     assert(ios.width() == 0);
   23586                                 }
   23587                                 ios.width(25);
   23588                                 internal(ios);
   23589                                 {
   23590                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23591                                     std::string ex(str, iter.base());
   23592                                     assert(ex == "-******************0X0P+0");
   23593                                     assert(ios.width() == 0);
   23594                                 }
   23595                             }
   23596                         }
   23597                         showpoint(ios);
   23598                         {
   23599                             ios.imbue(lc);
   23600                             {
   23601                                 ios.width(0);
   23602                                 {
   23603                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23604                                     std::string ex(str, iter.base());
   23605                                     assert(ex == "-0X0.P+0");
   23606                                     assert(ios.width() == 0);
   23607                                 }
   23608                                 ios.width(25);
   23609                                 left(ios);
   23610                                 {
   23611                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23612                                     std::string ex(str, iter.base());
   23613                                     assert(ex == "-0X0.P+0*****************");
   23614                                     assert(ios.width() == 0);
   23615                                 }
   23616                                 ios.width(25);
   23617                                 right(ios);
   23618                                 {
   23619                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23620                                     std::string ex(str, iter.base());
   23621                                     assert(ex == "*****************-0X0.P+0");
   23622                                     assert(ios.width() == 0);
   23623                                 }
   23624                                 ios.width(25);
   23625                                 internal(ios);
   23626                                 {
   23627                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23628                                     std::string ex(str, iter.base());
   23629                                     assert(ex == "-*****************0X0.P+0");
   23630                                     assert(ios.width() == 0);
   23631                                 }
   23632                             }
   23633                             ios.imbue(lg);
   23634                             {
   23635                                 ios.width(0);
   23636                                 {
   23637                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23638                                     std::string ex(str, iter.base());
   23639                                     assert(ex == "-0X0;P+0");
   23640                                     assert(ios.width() == 0);
   23641                                 }
   23642                                 ios.width(25);
   23643                                 left(ios);
   23644                                 {
   23645                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23646                                     std::string ex(str, iter.base());
   23647                                     assert(ex == "-0X0;P+0*****************");
   23648                                     assert(ios.width() == 0);
   23649                                 }
   23650                                 ios.width(25);
   23651                                 right(ios);
   23652                                 {
   23653                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23654                                     std::string ex(str, iter.base());
   23655                                     assert(ex == "*****************-0X0;P+0");
   23656                                     assert(ios.width() == 0);
   23657                                 }
   23658                                 ios.width(25);
   23659                                 internal(ios);
   23660                                 {
   23661                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23662                                     std::string ex(str, iter.base());
   23663                                     assert(ex == "-*****************0X0;P+0");
   23664                                     assert(ios.width() == 0);
   23665                                 }
   23666                             }
   23667                         }
   23668                     }
   23669                     showpos(ios);
   23670                     {
   23671                         noshowpoint(ios);
   23672                         {
   23673                             ios.imbue(lc);
   23674                             {
   23675                                 ios.width(0);
   23676                                 {
   23677                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23678                                     std::string ex(str, iter.base());
   23679                                     assert(ex == "-0X0P+0");
   23680                                     assert(ios.width() == 0);
   23681                                 }
   23682                                 ios.width(25);
   23683                                 left(ios);
   23684                                 {
   23685                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23686                                     std::string ex(str, iter.base());
   23687                                     assert(ex == "-0X0P+0******************");
   23688                                     assert(ios.width() == 0);
   23689                                 }
   23690                                 ios.width(25);
   23691                                 right(ios);
   23692                                 {
   23693                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23694                                     std::string ex(str, iter.base());
   23695                                     assert(ex == "******************-0X0P+0");
   23696                                     assert(ios.width() == 0);
   23697                                 }
   23698                                 ios.width(25);
   23699                                 internal(ios);
   23700                                 {
   23701                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23702                                     std::string ex(str, iter.base());
   23703                                     assert(ex == "-******************0X0P+0");
   23704                                     assert(ios.width() == 0);
   23705                                 }
   23706                             }
   23707                             ios.imbue(lg);
   23708                             {
   23709                                 ios.width(0);
   23710                                 {
   23711                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23712                                     std::string ex(str, iter.base());
   23713                                     assert(ex == "-0X0P+0");
   23714                                     assert(ios.width() == 0);
   23715                                 }
   23716                                 ios.width(25);
   23717                                 left(ios);
   23718                                 {
   23719                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23720                                     std::string ex(str, iter.base());
   23721                                     assert(ex == "-0X0P+0******************");
   23722                                     assert(ios.width() == 0);
   23723                                 }
   23724                                 ios.width(25);
   23725                                 right(ios);
   23726                                 {
   23727                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23728                                     std::string ex(str, iter.base());
   23729                                     assert(ex == "******************-0X0P+0");
   23730                                     assert(ios.width() == 0);
   23731                                 }
   23732                                 ios.width(25);
   23733                                 internal(ios);
   23734                                 {
   23735                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23736                                     std::string ex(str, iter.base());
   23737                                     assert(ex == "-******************0X0P+0");
   23738                                     assert(ios.width() == 0);
   23739                                 }
   23740                             }
   23741                         }
   23742                         showpoint(ios);
   23743                         {
   23744                             ios.imbue(lc);
   23745                             {
   23746                                 ios.width(0);
   23747                                 {
   23748                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23749                                     std::string ex(str, iter.base());
   23750                                     assert(ex == "-0X0.P+0");
   23751                                     assert(ios.width() == 0);
   23752                                 }
   23753                                 ios.width(25);
   23754                                 left(ios);
   23755                                 {
   23756                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23757                                     std::string ex(str, iter.base());
   23758                                     assert(ex == "-0X0.P+0*****************");
   23759                                     assert(ios.width() == 0);
   23760                                 }
   23761                                 ios.width(25);
   23762                                 right(ios);
   23763                                 {
   23764                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23765                                     std::string ex(str, iter.base());
   23766                                     assert(ex == "*****************-0X0.P+0");
   23767                                     assert(ios.width() == 0);
   23768                                 }
   23769                                 ios.width(25);
   23770                                 internal(ios);
   23771                                 {
   23772                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23773                                     std::string ex(str, iter.base());
   23774                                     assert(ex == "-*****************0X0.P+0");
   23775                                     assert(ios.width() == 0);
   23776                                 }
   23777                             }
   23778                             ios.imbue(lg);
   23779                             {
   23780                                 ios.width(0);
   23781                                 {
   23782                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23783                                     std::string ex(str, iter.base());
   23784                                     assert(ex == "-0X0;P+0");
   23785                                     assert(ios.width() == 0);
   23786                                 }
   23787                                 ios.width(25);
   23788                                 left(ios);
   23789                                 {
   23790                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23791                                     std::string ex(str, iter.base());
   23792                                     assert(ex == "-0X0;P+0*****************");
   23793                                     assert(ios.width() == 0);
   23794                                 }
   23795                                 ios.width(25);
   23796                                 right(ios);
   23797                                 {
   23798                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23799                                     std::string ex(str, iter.base());
   23800                                     assert(ex == "*****************-0X0;P+0");
   23801                                     assert(ios.width() == 0);
   23802                                 }
   23803                                 ios.width(25);
   23804                                 internal(ios);
   23805                                 {
   23806                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23807                                     std::string ex(str, iter.base());
   23808                                     assert(ex == "-*****************0X0;P+0");
   23809                                     assert(ios.width() == 0);
   23810                                 }
   23811                             }
   23812                         }
   23813                     }
   23814                 }
   23815             }
   23816             ios.precision(6);
   23817             {
   23818                 nouppercase(ios);
   23819                 {
   23820                     noshowpos(ios);
   23821                     {
   23822                         noshowpoint(ios);
   23823                         {
   23824                             ios.imbue(lc);
   23825                             {
   23826                                 ios.width(0);
   23827                                 {
   23828                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23829                                     std::string ex(str, iter.base());
   23830                                     assert(ex == "-0x0p+0");
   23831                                     assert(ios.width() == 0);
   23832                                 }
   23833                                 ios.width(25);
   23834                                 left(ios);
   23835                                 {
   23836                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23837                                     std::string ex(str, iter.base());
   23838                                     assert(ex == "-0x0p+0******************");
   23839                                     assert(ios.width() == 0);
   23840                                 }
   23841                                 ios.width(25);
   23842                                 right(ios);
   23843                                 {
   23844                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23845                                     std::string ex(str, iter.base());
   23846                                     assert(ex == "******************-0x0p+0");
   23847                                     assert(ios.width() == 0);
   23848                                 }
   23849                                 ios.width(25);
   23850                                 internal(ios);
   23851                                 {
   23852                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23853                                     std::string ex(str, iter.base());
   23854                                     assert(ex == "-******************0x0p+0");
   23855                                     assert(ios.width() == 0);
   23856                                 }
   23857                             }
   23858                             ios.imbue(lg);
   23859                             {
   23860                                 ios.width(0);
   23861                                 {
   23862                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23863                                     std::string ex(str, iter.base());
   23864                                     assert(ex == "-0x0p+0");
   23865                                     assert(ios.width() == 0);
   23866                                 }
   23867                                 ios.width(25);
   23868                                 left(ios);
   23869                                 {
   23870                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23871                                     std::string ex(str, iter.base());
   23872                                     assert(ex == "-0x0p+0******************");
   23873                                     assert(ios.width() == 0);
   23874                                 }
   23875                                 ios.width(25);
   23876                                 right(ios);
   23877                                 {
   23878                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23879                                     std::string ex(str, iter.base());
   23880                                     assert(ex == "******************-0x0p+0");
   23881                                     assert(ios.width() == 0);
   23882                                 }
   23883                                 ios.width(25);
   23884                                 internal(ios);
   23885                                 {
   23886                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23887                                     std::string ex(str, iter.base());
   23888                                     assert(ex == "-******************0x0p+0");
   23889                                     assert(ios.width() == 0);
   23890                                 }
   23891                             }
   23892                         }
   23893                         showpoint(ios);
   23894                         {
   23895                             ios.imbue(lc);
   23896                             {
   23897                                 ios.width(0);
   23898                                 {
   23899                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23900                                     std::string ex(str, iter.base());
   23901                                     assert(ex == "-0x0.p+0");
   23902                                     assert(ios.width() == 0);
   23903                                 }
   23904                                 ios.width(25);
   23905                                 left(ios);
   23906                                 {
   23907                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23908                                     std::string ex(str, iter.base());
   23909                                     assert(ex == "-0x0.p+0*****************");
   23910                                     assert(ios.width() == 0);
   23911                                 }
   23912                                 ios.width(25);
   23913                                 right(ios);
   23914                                 {
   23915                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23916                                     std::string ex(str, iter.base());
   23917                                     assert(ex == "*****************-0x0.p+0");
   23918                                     assert(ios.width() == 0);
   23919                                 }
   23920                                 ios.width(25);
   23921                                 internal(ios);
   23922                                 {
   23923                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23924                                     std::string ex(str, iter.base());
   23925                                     assert(ex == "-*****************0x0.p+0");
   23926                                     assert(ios.width() == 0);
   23927                                 }
   23928                             }
   23929                             ios.imbue(lg);
   23930                             {
   23931                                 ios.width(0);
   23932                                 {
   23933                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23934                                     std::string ex(str, iter.base());
   23935                                     assert(ex == "-0x0;p+0");
   23936                                     assert(ios.width() == 0);
   23937                                 }
   23938                                 ios.width(25);
   23939                                 left(ios);
   23940                                 {
   23941                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23942                                     std::string ex(str, iter.base());
   23943                                     assert(ex == "-0x0;p+0*****************");
   23944                                     assert(ios.width() == 0);
   23945                                 }
   23946                                 ios.width(25);
   23947                                 right(ios);
   23948                                 {
   23949                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23950                                     std::string ex(str, iter.base());
   23951                                     assert(ex == "*****************-0x0;p+0");
   23952                                     assert(ios.width() == 0);
   23953                                 }
   23954                                 ios.width(25);
   23955                                 internal(ios);
   23956                                 {
   23957                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23958                                     std::string ex(str, iter.base());
   23959                                     assert(ex == "-*****************0x0;p+0");
   23960                                     assert(ios.width() == 0);
   23961                                 }
   23962                             }
   23963                         }
   23964                     }
   23965                     showpos(ios);
   23966                     {
   23967                         noshowpoint(ios);
   23968                         {
   23969                             ios.imbue(lc);
   23970                             {
   23971                                 ios.width(0);
   23972                                 {
   23973                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23974                                     std::string ex(str, iter.base());
   23975                                     assert(ex == "-0x0p+0");
   23976                                     assert(ios.width() == 0);
   23977                                 }
   23978                                 ios.width(25);
   23979                                 left(ios);
   23980                                 {
   23981                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23982                                     std::string ex(str, iter.base());
   23983                                     assert(ex == "-0x0p+0******************");
   23984                                     assert(ios.width() == 0);
   23985                                 }
   23986                                 ios.width(25);
   23987                                 right(ios);
   23988                                 {
   23989                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23990                                     std::string ex(str, iter.base());
   23991                                     assert(ex == "******************-0x0p+0");
   23992                                     assert(ios.width() == 0);
   23993                                 }
   23994                                 ios.width(25);
   23995                                 internal(ios);
   23996                                 {
   23997                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23998                                     std::string ex(str, iter.base());
   23999                                     assert(ex == "-******************0x0p+0");
   24000                                     assert(ios.width() == 0);
   24001                                 }
   24002                             }
   24003                             ios.imbue(lg);
   24004                             {
   24005                                 ios.width(0);
   24006                                 {
   24007                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24008                                     std::string ex(str, iter.base());
   24009                                     assert(ex == "-0x0p+0");
   24010                                     assert(ios.width() == 0);
   24011                                 }
   24012                                 ios.width(25);
   24013                                 left(ios);
   24014                                 {
   24015                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24016                                     std::string ex(str, iter.base());
   24017                                     assert(ex == "-0x0p+0******************");
   24018                                     assert(ios.width() == 0);
   24019                                 }
   24020                                 ios.width(25);
   24021                                 right(ios);
   24022                                 {
   24023                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24024                                     std::string ex(str, iter.base());
   24025                                     assert(ex == "******************-0x0p+0");
   24026                                     assert(ios.width() == 0);
   24027                                 }
   24028                                 ios.width(25);
   24029                                 internal(ios);
   24030                                 {
   24031                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24032                                     std::string ex(str, iter.base());
   24033                                     assert(ex == "-******************0x0p+0");
   24034                                     assert(ios.width() == 0);
   24035                                 }
   24036                             }
   24037                         }
   24038                         showpoint(ios);
   24039                         {
   24040                             ios.imbue(lc);
   24041                             {
   24042                                 ios.width(0);
   24043                                 {
   24044                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24045                                     std::string ex(str, iter.base());
   24046                                     assert(ex == "-0x0.p+0");
   24047                                     assert(ios.width() == 0);
   24048                                 }
   24049                                 ios.width(25);
   24050                                 left(ios);
   24051                                 {
   24052                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24053                                     std::string ex(str, iter.base());
   24054                                     assert(ex == "-0x0.p+0*****************");
   24055                                     assert(ios.width() == 0);
   24056                                 }
   24057                                 ios.width(25);
   24058                                 right(ios);
   24059                                 {
   24060                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24061                                     std::string ex(str, iter.base());
   24062                                     assert(ex == "*****************-0x0.p+0");
   24063                                     assert(ios.width() == 0);
   24064                                 }
   24065                                 ios.width(25);
   24066                                 internal(ios);
   24067                                 {
   24068                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24069                                     std::string ex(str, iter.base());
   24070                                     assert(ex == "-*****************0x0.p+0");
   24071                                     assert(ios.width() == 0);
   24072                                 }
   24073                             }
   24074                             ios.imbue(lg);
   24075                             {
   24076                                 ios.width(0);
   24077                                 {
   24078                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24079                                     std::string ex(str, iter.base());
   24080                                     assert(ex == "-0x0;p+0");
   24081                                     assert(ios.width() == 0);
   24082                                 }
   24083                                 ios.width(25);
   24084                                 left(ios);
   24085                                 {
   24086                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24087                                     std::string ex(str, iter.base());
   24088                                     assert(ex == "-0x0;p+0*****************");
   24089                                     assert(ios.width() == 0);
   24090                                 }
   24091                                 ios.width(25);
   24092                                 right(ios);
   24093                                 {
   24094                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24095                                     std::string ex(str, iter.base());
   24096                                     assert(ex == "*****************-0x0;p+0");
   24097                                     assert(ios.width() == 0);
   24098                                 }
   24099                                 ios.width(25);
   24100                                 internal(ios);
   24101                                 {
   24102                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24103                                     std::string ex(str, iter.base());
   24104                                     assert(ex == "-*****************0x0;p+0");
   24105                                     assert(ios.width() == 0);
   24106                                 }
   24107                             }
   24108                         }
   24109                     }
   24110                 }
   24111                 uppercase(ios);
   24112                 {
   24113                     noshowpos(ios);
   24114                     {
   24115                         noshowpoint(ios);
   24116                         {
   24117                             ios.imbue(lc);
   24118                             {
   24119                                 ios.width(0);
   24120                                 {
   24121                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24122                                     std::string ex(str, iter.base());
   24123                                     assert(ex == "-0X0P+0");
   24124                                     assert(ios.width() == 0);
   24125                                 }
   24126                                 ios.width(25);
   24127                                 left(ios);
   24128                                 {
   24129                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24130                                     std::string ex(str, iter.base());
   24131                                     assert(ex == "-0X0P+0******************");
   24132                                     assert(ios.width() == 0);
   24133                                 }
   24134                                 ios.width(25);
   24135                                 right(ios);
   24136                                 {
   24137                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24138                                     std::string ex(str, iter.base());
   24139                                     assert(ex == "******************-0X0P+0");
   24140                                     assert(ios.width() == 0);
   24141                                 }
   24142                                 ios.width(25);
   24143                                 internal(ios);
   24144                                 {
   24145                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24146                                     std::string ex(str, iter.base());
   24147                                     assert(ex == "-******************0X0P+0");
   24148                                     assert(ios.width() == 0);
   24149                                 }
   24150                             }
   24151                             ios.imbue(lg);
   24152                             {
   24153                                 ios.width(0);
   24154                                 {
   24155                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24156                                     std::string ex(str, iter.base());
   24157                                     assert(ex == "-0X0P+0");
   24158                                     assert(ios.width() == 0);
   24159                                 }
   24160                                 ios.width(25);
   24161                                 left(ios);
   24162                                 {
   24163                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24164                                     std::string ex(str, iter.base());
   24165                                     assert(ex == "-0X0P+0******************");
   24166                                     assert(ios.width() == 0);
   24167                                 }
   24168                                 ios.width(25);
   24169                                 right(ios);
   24170                                 {
   24171                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24172                                     std::string ex(str, iter.base());
   24173                                     assert(ex == "******************-0X0P+0");
   24174                                     assert(ios.width() == 0);
   24175                                 }
   24176                                 ios.width(25);
   24177                                 internal(ios);
   24178                                 {
   24179                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24180                                     std::string ex(str, iter.base());
   24181                                     assert(ex == "-******************0X0P+0");
   24182                                     assert(ios.width() == 0);
   24183                                 }
   24184                             }
   24185                         }
   24186                         showpoint(ios);
   24187                         {
   24188                             ios.imbue(lc);
   24189                             {
   24190                                 ios.width(0);
   24191                                 {
   24192                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24193                                     std::string ex(str, iter.base());
   24194                                     assert(ex == "-0X0.P+0");
   24195                                     assert(ios.width() == 0);
   24196                                 }
   24197                                 ios.width(25);
   24198                                 left(ios);
   24199                                 {
   24200                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24201                                     std::string ex(str, iter.base());
   24202                                     assert(ex == "-0X0.P+0*****************");
   24203                                     assert(ios.width() == 0);
   24204                                 }
   24205                                 ios.width(25);
   24206                                 right(ios);
   24207                                 {
   24208                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24209                                     std::string ex(str, iter.base());
   24210                                     assert(ex == "*****************-0X0.P+0");
   24211                                     assert(ios.width() == 0);
   24212                                 }
   24213                                 ios.width(25);
   24214                                 internal(ios);
   24215                                 {
   24216                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24217                                     std::string ex(str, iter.base());
   24218                                     assert(ex == "-*****************0X0.P+0");
   24219                                     assert(ios.width() == 0);
   24220                                 }
   24221                             }
   24222                             ios.imbue(lg);
   24223                             {
   24224                                 ios.width(0);
   24225                                 {
   24226                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24227                                     std::string ex(str, iter.base());
   24228                                     assert(ex == "-0X0;P+0");
   24229                                     assert(ios.width() == 0);
   24230                                 }
   24231                                 ios.width(25);
   24232                                 left(ios);
   24233                                 {
   24234                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24235                                     std::string ex(str, iter.base());
   24236                                     assert(ex == "-0X0;P+0*****************");
   24237                                     assert(ios.width() == 0);
   24238                                 }
   24239                                 ios.width(25);
   24240                                 right(ios);
   24241                                 {
   24242                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24243                                     std::string ex(str, iter.base());
   24244                                     assert(ex == "*****************-0X0;P+0");
   24245                                     assert(ios.width() == 0);
   24246                                 }
   24247                                 ios.width(25);
   24248                                 internal(ios);
   24249                                 {
   24250                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24251                                     std::string ex(str, iter.base());
   24252                                     assert(ex == "-*****************0X0;P+0");
   24253                                     assert(ios.width() == 0);
   24254                                 }
   24255                             }
   24256                         }
   24257                     }
   24258                     showpos(ios);
   24259                     {
   24260                         noshowpoint(ios);
   24261                         {
   24262                             ios.imbue(lc);
   24263                             {
   24264                                 ios.width(0);
   24265                                 {
   24266                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24267                                     std::string ex(str, iter.base());
   24268                                     assert(ex == "-0X0P+0");
   24269                                     assert(ios.width() == 0);
   24270                                 }
   24271                                 ios.width(25);
   24272                                 left(ios);
   24273                                 {
   24274                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24275                                     std::string ex(str, iter.base());
   24276                                     assert(ex == "-0X0P+0******************");
   24277                                     assert(ios.width() == 0);
   24278                                 }
   24279                                 ios.width(25);
   24280                                 right(ios);
   24281                                 {
   24282                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24283                                     std::string ex(str, iter.base());
   24284                                     assert(ex == "******************-0X0P+0");
   24285                                     assert(ios.width() == 0);
   24286                                 }
   24287                                 ios.width(25);
   24288                                 internal(ios);
   24289                                 {
   24290                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24291                                     std::string ex(str, iter.base());
   24292                                     assert(ex == "-******************0X0P+0");
   24293                                     assert(ios.width() == 0);
   24294                                 }
   24295                             }
   24296                             ios.imbue(lg);
   24297                             {
   24298                                 ios.width(0);
   24299                                 {
   24300                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24301                                     std::string ex(str, iter.base());
   24302                                     assert(ex == "-0X0P+0");
   24303                                     assert(ios.width() == 0);
   24304                                 }
   24305                                 ios.width(25);
   24306                                 left(ios);
   24307                                 {
   24308                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24309                                     std::string ex(str, iter.base());
   24310                                     assert(ex == "-0X0P+0******************");
   24311                                     assert(ios.width() == 0);
   24312                                 }
   24313                                 ios.width(25);
   24314                                 right(ios);
   24315                                 {
   24316                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24317                                     std::string ex(str, iter.base());
   24318                                     assert(ex == "******************-0X0P+0");
   24319                                     assert(ios.width() == 0);
   24320                                 }
   24321                                 ios.width(25);
   24322                                 internal(ios);
   24323                                 {
   24324                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24325                                     std::string ex(str, iter.base());
   24326                                     assert(ex == "-******************0X0P+0");
   24327                                     assert(ios.width() == 0);
   24328                                 }
   24329                             }
   24330                         }
   24331                         showpoint(ios);
   24332                         {
   24333                             ios.imbue(lc);
   24334                             {
   24335                                 ios.width(0);
   24336                                 {
   24337                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24338                                     std::string ex(str, iter.base());
   24339                                     assert(ex == "-0X0.P+0");
   24340                                     assert(ios.width() == 0);
   24341                                 }
   24342                                 ios.width(25);
   24343                                 left(ios);
   24344                                 {
   24345                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24346                                     std::string ex(str, iter.base());
   24347                                     assert(ex == "-0X0.P+0*****************");
   24348                                     assert(ios.width() == 0);
   24349                                 }
   24350                                 ios.width(25);
   24351                                 right(ios);
   24352                                 {
   24353                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24354                                     std::string ex(str, iter.base());
   24355                                     assert(ex == "*****************-0X0.P+0");
   24356                                     assert(ios.width() == 0);
   24357                                 }
   24358                                 ios.width(25);
   24359                                 internal(ios);
   24360                                 {
   24361                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24362                                     std::string ex(str, iter.base());
   24363                                     assert(ex == "-*****************0X0.P+0");
   24364                                     assert(ios.width() == 0);
   24365                                 }
   24366                             }
   24367                             ios.imbue(lg);
   24368                             {
   24369                                 ios.width(0);
   24370                                 {
   24371                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24372                                     std::string ex(str, iter.base());
   24373                                     assert(ex == "-0X0;P+0");
   24374                                     assert(ios.width() == 0);
   24375                                 }
   24376                                 ios.width(25);
   24377                                 left(ios);
   24378                                 {
   24379                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24380                                     std::string ex(str, iter.base());
   24381                                     assert(ex == "-0X0;P+0*****************");
   24382                                     assert(ios.width() == 0);
   24383                                 }
   24384                                 ios.width(25);
   24385                                 right(ios);
   24386                                 {
   24387                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24388                                     std::string ex(str, iter.base());
   24389                                     assert(ex == "*****************-0X0;P+0");
   24390                                     assert(ios.width() == 0);
   24391                                 }
   24392                                 ios.width(25);
   24393                                 internal(ios);
   24394                                 {
   24395                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24396                                     std::string ex(str, iter.base());
   24397                                     assert(ex == "-*****************0X0;P+0");
   24398                                     assert(ios.width() == 0);
   24399                                 }
   24400                             }
   24401                         }
   24402                     }
   24403                 }
   24404             }
   24405             ios.precision(16);
   24406             {
   24407             }
   24408             ios.precision(60);
   24409             {
   24410             }
   24411         }
   24412     }
   24413 }
   24414 
   24415 void test12()
   24416 {
   24417     char str[200];
   24418     output_iterator<char*> iter;
   24419     std::locale lc = std::locale::classic();
   24420     std::locale lg(lc, new my_numpunct);
   24421 #ifdef __APPLE__
   24422 // This test is failing on FreeBSD, possibly due to different representations
   24423 // of the floating point numbers.
   24424     const my_facet f(1);
   24425     {
   24426         long double v = 1234567890.125;
   24427         std::ios ios(0);
   24428         hexfloat(ios);
   24429         // %a
   24430         {
   24431             ios.precision(0);
   24432             {
   24433                 nouppercase(ios);
   24434                 {
   24435                     noshowpos(ios);
   24436                     {
   24437                         noshowpoint(ios);
   24438                         {
   24439                                 ios.width(0);
   24440                             ios.imbue(lc);
   24441                             {
   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                                 left(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                                 right(ios);
   24458                                 {
   24459                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24460                                     std::string ex(str, iter.base());
   24461                                     assert(ex == "*********0x9.32c05a44p+27");
   24462                                     assert(ios.width() == 0);
   24463                                 }
   24464                                 ios.width(25);
   24465                                 internal(ios);
   24466                                 {
   24467                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24468                                     std::string ex(str, iter.base());
   24469                                     assert(ex == "0x*********9.32c05a44p+27");
   24470                                     assert(ios.width() == 0);
   24471                                 }
   24472                             }
   24473                             ios.imbue(lg);
   24474                             {
   24475                                 ios.width(0);
   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                                 left(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                                 right(ios);
   24492                                 {
   24493                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24494                                     std::string ex(str, iter.base());
   24495                                     assert(ex == "*********0x9;32c05a44p+27");
   24496                                     assert(ios.width() == 0);
   24497                                 }
   24498                                 ios.width(25);
   24499                                 internal(ios);
   24500                                 {
   24501                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24502                                     std::string ex(str, iter.base());
   24503                                     assert(ex == "0x*********9;32c05a44p+27");
   24504                                     assert(ios.width() == 0);
   24505                                 }
   24506                             }
   24507                         }
   24508                         showpoint(ios);
   24509                         {
   24510                             ios.imbue(lc);
   24511                             {
   24512                                 ios.width(0);
   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                                 left(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                                 right(ios);
   24529                                 {
   24530                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24531                                     std::string ex(str, iter.base());
   24532                                     assert(ex == "*********0x9.32c05a44p+27");
   24533                                     assert(ios.width() == 0);
   24534                                 }
   24535                                 ios.width(25);
   24536                                 internal(ios);
   24537                                 {
   24538                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24539                                     std::string ex(str, iter.base());
   24540                                     assert(ex == "0x*********9.32c05a44p+27");
   24541                                     assert(ios.width() == 0);
   24542                                 }
   24543                             }
   24544                             ios.imbue(lg);
   24545                             {
   24546                                 ios.width(0);
   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                                 left(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                                 right(ios);
   24563                                 {
   24564                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24565                                     std::string ex(str, iter.base());
   24566                                     assert(ex == "*********0x9;32c05a44p+27");
   24567                                     assert(ios.width() == 0);
   24568                                 }
   24569                                 ios.width(25);
   24570                                 internal(ios);
   24571                                 {
   24572                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24573                                     std::string ex(str, iter.base());
   24574                                     assert(ex == "0x*********9;32c05a44p+27");
   24575                                     assert(ios.width() == 0);
   24576                                 }
   24577                             }
   24578                         }
   24579                     }
   24580                     showpos(ios);
   24581                     {
   24582                         noshowpoint(ios);
   24583                         {
   24584                             ios.imbue(lc);
   24585                             {
   24586                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   24610                                 internal(ios);
   24611                                 {
   24612                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24613                                     std::string ex(str, iter.base());
   24614                                     assert(ex == "+********0x9.32c05a44p+27");
   24615                                     assert(ios.width() == 0);
   24616                                 }
   24617                             }
   24618                             ios.imbue(lg);
   24619                             {
   24620                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   24644                                 internal(ios);
   24645                                 {
   24646                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24647                                     std::string ex(str, iter.base());
   24648                                     assert(ex == "+********0x9;32c05a44p+27");
   24649                                     assert(ios.width() == 0);
   24650                                 }
   24651                             }
   24652                         }
   24653                         showpoint(ios);
   24654                         {
   24655                             ios.imbue(lc);
   24656                             {
   24657                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   24681                                 internal(ios);
   24682                                 {
   24683                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24684                                     std::string ex(str, iter.base());
   24685                                     assert(ex == "+********0x9.32c05a44p+27");
   24686                                     assert(ios.width() == 0);
   24687                                 }
   24688                             }
   24689                             ios.imbue(lg);
   24690                             {
   24691                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   24715                                 internal(ios);
   24716                                 {
   24717                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24718                                     std::string ex(str, iter.base());
   24719                                     assert(ex == "+********0x9;32c05a44p+27");
   24720                                     assert(ios.width() == 0);
   24721                                 }
   24722                             }
   24723                         }
   24724                     }
   24725                 }
   24726                 uppercase(ios);
   24727                 {
   24728                     noshowpos(ios);
   24729                     {
   24730                         noshowpoint(ios);
   24731                         {
   24732                             ios.imbue(lc);
   24733                             {
   24734                                 ios.width(0);
   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                                 left(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                                 right(ios);
   24751                                 {
   24752                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24753                                     std::string ex(str, iter.base());
   24754                                     assert(ex == "*********0X9.32C05A44P+27");
   24755                                     assert(ios.width() == 0);
   24756                                 }
   24757                                 ios.width(25);
   24758                                 internal(ios);
   24759                                 {
   24760                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24761                                     std::string ex(str, iter.base());
   24762                                     assert(ex == "0X*********9.32C05A44P+27");
   24763                                     assert(ios.width() == 0);
   24764                                 }
   24765                             }
   24766                             ios.imbue(lg);
   24767                             {
   24768                                 ios.width(0);
   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                                 left(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                                 right(ios);
   24785                                 {
   24786                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24787                                     std::string ex(str, iter.base());
   24788                                     assert(ex == "*********0X9;32C05A44P+27");
   24789                                     assert(ios.width() == 0);
   24790                                 }
   24791                                 ios.width(25);
   24792                                 internal(ios);
   24793                                 {
   24794                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24795                                     std::string ex(str, iter.base());
   24796                                     assert(ex == "0X*********9;32C05A44P+27");
   24797                                     assert(ios.width() == 0);
   24798                                 }
   24799                             }
   24800                         }
   24801                         showpoint(ios);
   24802                         {
   24803                             ios.imbue(lc);
   24804                             {
   24805                                 ios.width(0);
   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                                 left(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                                 right(ios);
   24822                                 {
   24823                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24824                                     std::string ex(str, iter.base());
   24825                                     assert(ex == "*********0X9.32C05A44P+27");
   24826                                     assert(ios.width() == 0);
   24827                                 }
   24828                                 ios.width(25);
   24829                                 internal(ios);
   24830                                 {
   24831                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24832                                     std::string ex(str, iter.base());
   24833                                     assert(ex == "0X*********9.32C05A44P+27");
   24834                                     assert(ios.width() == 0);
   24835                                 }
   24836                             }
   24837                             ios.imbue(lg);
   24838                             {
   24839                                 ios.width(0);
   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                                 left(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                                 right(ios);
   24856                                 {
   24857                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24858                                     std::string ex(str, iter.base());
   24859                                     assert(ex == "*********0X9;32C05A44P+27");
   24860                                     assert(ios.width() == 0);
   24861                                 }
   24862                                 ios.width(25);
   24863                                 internal(ios);
   24864                                 {
   24865                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24866                                     std::string ex(str, iter.base());
   24867                                     assert(ex == "0X*********9;32C05A44P+27");
   24868                                     assert(ios.width() == 0);
   24869                                 }
   24870                             }
   24871                         }
   24872                     }
   24873                     showpos(ios);
   24874                     {
   24875                         noshowpoint(ios);
   24876                         {
   24877                             ios.imbue(lc);
   24878                             {
   24879                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   24903                                 internal(ios);
   24904                                 {
   24905                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24906                                     std::string ex(str, iter.base());
   24907                                     assert(ex == "+********0X9.32C05A44P+27");
   24908                                     assert(ios.width() == 0);
   24909                                 }
   24910                             }
   24911                             ios.imbue(lg);
   24912                             {
   24913                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   24937                                 internal(ios);
   24938                                 {
   24939                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24940                                     std::string ex(str, iter.base());
   24941                                     assert(ex == "+********0X9;32C05A44P+27");
   24942                                     assert(ios.width() == 0);
   24943                                 }
   24944                             }
   24945                         }
   24946                         showpoint(ios);
   24947                         {
   24948                             ios.imbue(lc);
   24949                             {
   24950                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   24974                                 internal(ios);
   24975                                 {
   24976                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24977                                     std::string ex(str, iter.base());
   24978                                     assert(ex == "+********0X9.32C05A44P+27");
   24979                                     assert(ios.width() == 0);
   24980                                 }
   24981                             }
   24982                             ios.imbue(lg);
   24983                             {
   24984                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   25008                                 internal(ios);
   25009                                 {
   25010                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25011                                     std::string ex(str, iter.base());
   25012                                     assert(ex == "+********0X9;32C05A44P+27");
   25013                                     assert(ios.width() == 0);
   25014                                 }
   25015                             }
   25016                         }
   25017                     }
   25018                 }
   25019             }
   25020             ios.precision(1);
   25021             {
   25022                 nouppercase(ios);
   25023                 {
   25024                     noshowpos(ios);
   25025                     {
   25026                         noshowpoint(ios);
   25027                         {
   25028                             ios.imbue(lc);
   25029                             {
   25030                                 ios.width(0);
   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                                 left(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                                 right(ios);
   25047                                 {
   25048                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25049                                     std::string ex(str, iter.base());
   25050                                     assert(ex == "*********0x9.32c05a44p+27");
   25051                                     assert(ios.width() == 0);
   25052                                 }
   25053                                 ios.width(25);
   25054                                 internal(ios);
   25055                                 {
   25056                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25057                                     std::string ex(str, iter.base());
   25058                                     assert(ex == "0x*********9.32c05a44p+27");
   25059                                     assert(ios.width() == 0);
   25060                                 }
   25061                             }
   25062                             ios.imbue(lg);
   25063                             {
   25064                                 ios.width(0);
   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                                 left(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                                 right(ios);
   25081                                 {
   25082                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25083                                     std::string ex(str, iter.base());
   25084                                     assert(ex == "*********0x9;32c05a44p+27");
   25085                                     assert(ios.width() == 0);
   25086                                 }
   25087                                 ios.width(25);
   25088                                 internal(ios);
   25089                                 {
   25090                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25091                                     std::string ex(str, iter.base());
   25092                                     assert(ex == "0x*********9;32c05a44p+27");
   25093                                     assert(ios.width() == 0);
   25094                                 }
   25095                             }
   25096                         }
   25097                         showpoint(ios);
   25098                         {
   25099                             ios.imbue(lc);
   25100                             {
   25101                                 ios.width(0);
   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                                 left(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                                 right(ios);
   25118                                 {
   25119                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25120                                     std::string ex(str, iter.base());
   25121                                     assert(ex == "*********0x9.32c05a44p+27");
   25122                                     assert(ios.width() == 0);
   25123                                 }
   25124                                 ios.width(25);
   25125                                 internal(ios);
   25126                                 {
   25127                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25128                                     std::string ex(str, iter.base());
   25129                                     assert(ex == "0x*********9.32c05a44p+27");
   25130                                     assert(ios.width() == 0);
   25131                                 }
   25132                             }
   25133                             ios.imbue(lg);
   25134                             {
   25135                                 ios.width(0);
   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                                 left(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                                 right(ios);
   25152                                 {
   25153                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25154                                     std::string ex(str, iter.base());
   25155                                     assert(ex == "*********0x9;32c05a44p+27");
   25156                                     assert(ios.width() == 0);
   25157                                 }
   25158                                 ios.width(25);
   25159                                 internal(ios);
   25160                                 {
   25161                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25162                                     std::string ex(str, iter.base());
   25163                                     assert(ex == "0x*********9;32c05a44p+27");
   25164                                     assert(ios.width() == 0);
   25165                                 }
   25166                             }
   25167                         }
   25168                     }
   25169                     showpos(ios);
   25170                     {
   25171                         noshowpoint(ios);
   25172                         {
   25173                             ios.imbue(lc);
   25174                             {
   25175                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   25199                                 internal(ios);
   25200                                 {
   25201                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25202                                     std::string ex(str, iter.base());
   25203                                     assert(ex == "+********0x9.32c05a44p+27");
   25204                                     assert(ios.width() == 0);
   25205                                 }
   25206                             }
   25207                             ios.imbue(lg);
   25208                             {
   25209                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   25233                                 internal(ios);
   25234                                 {
   25235                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25236                                     std::string ex(str, iter.base());
   25237                                     assert(ex == "+********0x9;32c05a44p+27");
   25238                                     assert(ios.width() == 0);
   25239                                 }
   25240                             }
   25241                         }
   25242                         showpoint(ios);
   25243                         {
   25244                             ios.imbue(lc);
   25245                             {
   25246                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   25270                                 internal(ios);
   25271                                 {
   25272                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25273                                     std::string ex(str, iter.base());
   25274                                     assert(ex == "+********0x9.32c05a44p+27");
   25275                                     assert(ios.width() == 0);
   25276                                 }
   25277                             }
   25278                             ios.imbue(lg);
   25279                             {
   25280                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   25304                                 internal(ios);
   25305                                 {
   25306                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25307                                     std::string ex(str, iter.base());
   25308                                     assert(ex == "+********0x9;32c05a44p+27");
   25309                                     assert(ios.width() == 0);
   25310                                 }
   25311                             }
   25312                         }
   25313                     }
   25314                 }
   25315                 uppercase(ios);
   25316                 {
   25317                     noshowpos(ios);
   25318                     {
   25319                         noshowpoint(ios);
   25320                         {
   25321                             ios.imbue(lc);
   25322                             {
   25323                                 ios.width(0);
   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                                 left(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                                 right(ios);
   25340                                 {
   25341                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25342                                     std::string ex(str, iter.base());
   25343                                     assert(ex == "*********0X9.32C05A44P+27");
   25344                                     assert(ios.width() == 0);
   25345                                 }
   25346                                 ios.width(25);
   25347                                 internal(ios);
   25348                                 {
   25349                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25350                                     std::string ex(str, iter.base());
   25351                                     assert(ex == "0X*********9.32C05A44P+27");
   25352                                     assert(ios.width() == 0);
   25353                                 }
   25354                             }
   25355                             ios.imbue(lg);
   25356                             {
   25357                                 ios.width(0);
   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                                 left(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                                 right(ios);
   25374                                 {
   25375                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25376                                     std::string ex(str, iter.base());
   25377                                     assert(ex == "*********0X9;32C05A44P+27");
   25378                                     assert(ios.width() == 0);
   25379                                 }
   25380                                 ios.width(25);
   25381                                 internal(ios);
   25382                                 {
   25383                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25384                                     std::string ex(str, iter.base());
   25385                                     assert(ex == "0X*********9;32C05A44P+27");
   25386                                     assert(ios.width() == 0);
   25387                                 }
   25388                             }
   25389                         }
   25390                         showpoint(ios);
   25391                         {
   25392                             ios.imbue(lc);
   25393                             {
   25394                                 ios.width(0);
   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                                 left(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                                 right(ios);
   25411                                 {
   25412                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25413                                     std::string ex(str, iter.base());
   25414                                     assert(ex == "*********0X9.32C05A44P+27");
   25415                                     assert(ios.width() == 0);
   25416                                 }
   25417                                 ios.width(25);
   25418                                 internal(ios);
   25419                                 {
   25420                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25421                                     std::string ex(str, iter.base());
   25422                                     assert(ex == "0X*********9.32C05A44P+27");
   25423                                     assert(ios.width() == 0);
   25424                                 }
   25425                             }
   25426                             ios.imbue(lg);
   25427                             {
   25428                                 ios.width(0);
   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                                 left(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                                 right(ios);
   25445                                 {
   25446                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25447                                     std::string ex(str, iter.base());
   25448                                     assert(ex == "*********0X9;32C05A44P+27");
   25449                                     assert(ios.width() == 0);
   25450                                 }
   25451                                 ios.width(25);
   25452                                 internal(ios);
   25453                                 {
   25454                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25455                                     std::string ex(str, iter.base());
   25456                                     assert(ex == "0X*********9;32C05A44P+27");
   25457                                     assert(ios.width() == 0);
   25458                                 }
   25459                             }
   25460                         }
   25461                     }
   25462                     showpos(ios);
   25463                     {
   25464                         noshowpoint(ios);
   25465                         {
   25466                             ios.imbue(lc);
   25467                             {
   25468                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   25492                                 internal(ios);
   25493                                 {
   25494                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25495                                     std::string ex(str, iter.base());
   25496                                     assert(ex == "+********0X9.32C05A44P+27");
   25497                                     assert(ios.width() == 0);
   25498                                 }
   25499                             }
   25500                             ios.imbue(lg);
   25501                             {
   25502                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   25526                                 internal(ios);
   25527                                 {
   25528                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25529                                     std::string ex(str, iter.base());
   25530                                     assert(ex == "+********0X9;32C05A44P+27");
   25531                                     assert(ios.width() == 0);
   25532                                 }
   25533                             }
   25534                         }
   25535                         showpoint(ios);
   25536                         {
   25537                             ios.imbue(lc);
   25538                             {
   25539                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   25563                                 internal(ios);
   25564                                 {
   25565                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25566                                     std::string ex(str, iter.base());
   25567                                     assert(ex == "+********0X9.32C05A44P+27");
   25568                                     assert(ios.width() == 0);
   25569                                 }
   25570                             }
   25571                             ios.imbue(lg);
   25572                             {
   25573                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   25597                                 internal(ios);
   25598                                 {
   25599                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25600                                     std::string ex(str, iter.base());
   25601                                     assert(ex == "+********0X9;32C05A44P+27");
   25602                                     assert(ios.width() == 0);
   25603                                 }
   25604                             }
   25605                         }
   25606                     }
   25607                 }
   25608             }
   25609             ios.precision(6);
   25610             {
   25611             }
   25612             ios.precision(16);
   25613             {
   25614             }
   25615             ios.precision(60);
   25616             {
   25617                 nouppercase(ios);
   25618                 {
   25619                     noshowpos(ios);
   25620                     {
   25621                         noshowpoint(ios);
   25622                         {
   25623                             ios.imbue(lc);
   25624                             {
   25625                                 ios.width(0);
   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                                 left(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                                 right(ios);
   25642                                 {
   25643                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25644                                     std::string ex(str, iter.base());
   25645                                     assert(ex == "*********0x9.32c05a44p+27");
   25646                                     assert(ios.width() == 0);
   25647                                 }
   25648                                 ios.width(25);
   25649                                 internal(ios);
   25650                                 {
   25651                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25652                                     std::string ex(str, iter.base());
   25653                                     assert(ex == "0x*********9.32c05a44p+27");
   25654                                     assert(ios.width() == 0);
   25655                                 }
   25656                             }
   25657                             ios.imbue(lg);
   25658                             {
   25659                                 ios.width(0);
   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                                 left(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                                 right(ios);
   25676                                 {
   25677                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25678                                     std::string ex(str, iter.base());
   25679                                     assert(ex == "*********0x9;32c05a44p+27");
   25680                                     assert(ios.width() == 0);
   25681                                 }
   25682                                 ios.width(25);
   25683                                 internal(ios);
   25684                                 {
   25685                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25686                                     std::string ex(str, iter.base());
   25687                                     assert(ex == "0x*********9;32c05a44p+27");
   25688                                     assert(ios.width() == 0);
   25689                                 }
   25690                             }
   25691                         }
   25692                         showpoint(ios);
   25693                         {
   25694                             ios.imbue(lc);
   25695                             {
   25696                                 ios.width(0);
   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                                 left(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                                 right(ios);
   25713                                 {
   25714                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25715                                     std::string ex(str, iter.base());
   25716                                     assert(ex == "*********0x9.32c05a44p+27");
   25717                                     assert(ios.width() == 0);
   25718                                 }
   25719                                 ios.width(25);
   25720                                 internal(ios);
   25721                                 {
   25722                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25723                                     std::string ex(str, iter.base());
   25724                                     assert(ex == "0x*********9.32c05a44p+27");
   25725                                     assert(ios.width() == 0);
   25726                                 }
   25727                             }
   25728                             ios.imbue(lg);
   25729                             {
   25730                                 ios.width(0);
   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                                 left(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                                 right(ios);
   25747                                 {
   25748                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25749                                     std::string ex(str, iter.base());
   25750                                     assert(ex == "*********0x9;32c05a44p+27");
   25751                                     assert(ios.width() == 0);
   25752                                 }
   25753                                 ios.width(25);
   25754                                 internal(ios);
   25755                                 {
   25756                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25757                                     std::string ex(str, iter.base());
   25758                                     assert(ex == "0x*********9;32c05a44p+27");
   25759                                     assert(ios.width() == 0);
   25760                                 }
   25761                             }
   25762                         }
   25763                     }
   25764                     showpos(ios);
   25765                     {
   25766                         noshowpoint(ios);
   25767                         {
   25768                             ios.imbue(lc);
   25769                             {
   25770                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   25794                                 internal(ios);
   25795                                 {
   25796                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25797                                     std::string ex(str, iter.base());
   25798                                     assert(ex == "+********0x9.32c05a44p+27");
   25799                                     assert(ios.width() == 0);
   25800                                 }
   25801                             }
   25802                             ios.imbue(lg);
   25803                             {
   25804                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   25828                                 internal(ios);
   25829                                 {
   25830                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25831                                     std::string ex(str, iter.base());
   25832                                     assert(ex == "+********0x9;32c05a44p+27");
   25833                                     assert(ios.width() == 0);
   25834                                 }
   25835                             }
   25836                         }
   25837                         showpoint(ios);
   25838                         {
   25839                             ios.imbue(lc);
   25840                             {
   25841                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   25865                                 internal(ios);
   25866                                 {
   25867                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25868                                     std::string ex(str, iter.base());
   25869                                     assert(ex == "+********0x9.32c05a44p+27");
   25870                                     assert(ios.width() == 0);
   25871                                 }
   25872                             }
   25873                             ios.imbue(lg);
   25874                             {
   25875                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   25899                                 internal(ios);
   25900                                 {
   25901                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25902                                     std::string ex(str, iter.base());
   25903                                     assert(ex == "+********0x9;32c05a44p+27");
   25904                                     assert(ios.width() == 0);
   25905                                 }
   25906                             }
   25907                         }
   25908                     }
   25909                 }
   25910                 uppercase(ios);
   25911                 {
   25912                     noshowpos(ios);
   25913                     {
   25914                         noshowpoint(ios);
   25915                         {
   25916                             ios.imbue(lc);
   25917                             {
   25918                                 ios.width(0);
   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                                 left(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                                 right(ios);
   25935                                 {
   25936                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25937                                     std::string ex(str, iter.base());
   25938                                     assert(ex == "*********0X9.32C05A44P+27");
   25939                                     assert(ios.width() == 0);
   25940                                 }
   25941                                 ios.width(25);
   25942                                 internal(ios);
   25943                                 {
   25944                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25945                                     std::string ex(str, iter.base());
   25946                                     assert(ex == "0X*********9.32C05A44P+27");
   25947                                     assert(ios.width() == 0);
   25948                                 }
   25949                             }
   25950                             ios.imbue(lg);
   25951                             {
   25952                                 ios.width(0);
   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                                 left(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                                 right(ios);
   25969                                 {
   25970                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25971                                     std::string ex(str, iter.base());
   25972                                     assert(ex == "*********0X9;32C05A44P+27");
   25973                                     assert(ios.width() == 0);
   25974                                 }
   25975                                 ios.width(25);
   25976                                 internal(ios);
   25977                                 {
   25978                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25979                                     std::string ex(str, iter.base());
   25980                                     assert(ex == "0X*********9;32C05A44P+27");
   25981                                     assert(ios.width() == 0);
   25982                                 }
   25983                             }
   25984                         }
   25985                         showpoint(ios);
   25986                         {
   25987                             ios.imbue(lc);
   25988                             {
   25989                                 ios.width(0);
   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                                 left(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                                 right(ios);
   26006                                 {
   26007                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26008                                     std::string ex(str, iter.base());
   26009                                     assert(ex == "*********0X9.32C05A44P+27");
   26010                                     assert(ios.width() == 0);
   26011                                 }
   26012                                 ios.width(25);
   26013                                 internal(ios);
   26014                                 {
   26015                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26016                                     std::string ex(str, iter.base());
   26017                                     assert(ex == "0X*********9.32C05A44P+27");
   26018                                     assert(ios.width() == 0);
   26019                                 }
   26020                             }
   26021                             ios.imbue(lg);
   26022                             {
   26023                                 ios.width(0);
   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                                 left(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                                 right(ios);
   26040                                 {
   26041                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26042                                     std::string ex(str, iter.base());
   26043                                     assert(ex == "*********0X9;32C05A44P+27");
   26044                                     assert(ios.width() == 0);
   26045                                 }
   26046                                 ios.width(25);
   26047                                 internal(ios);
   26048                                 {
   26049                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26050                                     std::string ex(str, iter.base());
   26051                                     assert(ex == "0X*********9;32C05A44P+27");
   26052                                     assert(ios.width() == 0);
   26053                                 }
   26054                             }
   26055                         }
   26056                     }
   26057                     showpos(ios);
   26058                     {
   26059                         noshowpoint(ios);
   26060                         {
   26061                             ios.imbue(lc);
   26062                             {
   26063                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   26087                                 internal(ios);
   26088                                 {
   26089                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26090                                     std::string ex(str, iter.base());
   26091                                     assert(ex == "+********0X9.32C05A44P+27");
   26092                                     assert(ios.width() == 0);
   26093                                 }
   26094                             }
   26095                             ios.imbue(lg);
   26096                             {
   26097                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   26121                                 internal(ios);
   26122                                 {
   26123                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26124                                     std::string ex(str, iter.base());
   26125                                     assert(ex == "+********0X9;32C05A44P+27");
   26126                                     assert(ios.width() == 0);
   26127                                 }
   26128                             }
   26129                         }
   26130                         showpoint(ios);
   26131                         {
   26132                             ios.imbue(lc);
   26133                             {
   26134                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   26158                                 internal(ios);
   26159                                 {
   26160                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26161                                     std::string ex(str, iter.base());
   26162                                     assert(ex == "+********0X9.32C05A44P+27");
   26163                                     assert(ios.width() == 0);
   26164                                 }
   26165                             }
   26166                             ios.imbue(lg);
   26167                             {
   26168                                 ios.width(0);
   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                                 left(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                                 right(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                                 ios.width(25);
   26192                                 internal(ios);
   26193                                 {
   26194                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26195                                     std::string ex(str, iter.base());
   26196                                     assert(ex == "+********0X9;32C05A44P+27");
   26197                                     assert(ios.width() == 0);
   26198                                 }
   26199                             }
   26200                         }
   26201                     }
   26202                 }
   26203             }
   26204         }
   26205     }
   26206 #endif
   26207 }
   26208 
   26209 int main()
   26210 {
   26211     test1();
   26212     test2();
   26213     test3();
   26214     test4();
   26215     test5();
   26216     test6();
   26217     test7();
   26218     test8();
   26219     test9();
   26220     test10();
   26221     test11();
   26222     test12();
   26223     char str[200];
   26224     output_iterator<char*> iter;
   26225     std::locale lc = std::locale::classic();
   26226     std::locale lg(lc, new my_numpunct);
   26227     const my_facet f(1);
   26228     {
   26229         long double v = -INFINITY;
   26230     }
   26231     {
   26232         long double v = std::nan("");
   26233     }
   26234 
   26235     {
   26236         long double v = +0.;
   26237     }
   26238     {
   26239         long double v = -INFINITY;
   26240     }
   26241     {
   26242         long double v = std::nan("");
   26243     }
   26244     {
   26245         long double v = -INFINITY;
   26246     }
   26247     {
   26248         long double v = std::nan("");
   26249     }
   26250 }
   26251